From aa4c2b3ab36e8ce9380fea95f1f54126f6c5b89d Mon Sep 17 00:00:00 2001 From: Steve Date: Wed, 15 May 2024 11:45:19 +0900 Subject: [PATCH] Add missing types for WindowsCodec (#2167) * Strongly-typed WindowsCodec * Add more types to Win32 extras * Use IntPtr for handles * Bring back IMessageFilter * Minor fixes and resolving CR feedbacks * More fixes --- build/cache/wic.json.gz | Bin 59823 -> 236147 bytes build/cache/win32extras.json.gz | Bin 280774 -> 528322 bytes generator.json | 221 +- .../Enums/ActivateFlags.gen.cs | 18 + .../Enums/AspectInfoFlag.gen.cs | 18 + .../Enums/CTRLInfo.gen.cs | 26 + .../Enums/CallConv.gen.cs | 71 + .../Enums/ChangeKind.gen.cs | 56 + .../Enums/DVASPECT.gen.cs | 39 + .../Enums/DVASPECT2.gen.cs | 29 + .../Enums/DescKind.gen.cs | 46 + .../Enums/ExtentMode.gen.cs | 26 + .../Enums/FuncFlags.gen.cs | 84 + .../Enums/FuncKind.gen.cs | 41 + .../Enums/GuidKind.gen.cs | 18 + .../Enums/HitResult.gen.cs | 36 + .../Enums/InvokeKind.gen.cs | 39 + .../Enums/LibFlags.gen.cs | 39 + .../Enums/OLEDCFlags.gen.cs | 31 + .../Enums/PictureAttributes.gen.cs | 26 + .../Enums/PidmsiStatusValue.gen.cs | 66 + .../Enums/PointerInactive.gen.cs | 31 + .../Enums/PropBag2Type.gen.cs | 51 + .../Enums/PropPageStatus.gen.cs | 31 + .../Enums/ReadyState.gen.cs | 41 + .../Enums/SFType.gen.cs | 71 + .../Enums/STGC.gen.cs | 41 + .../Enums/STGMove.gen.cs | 31 + .../Enums/StatFlag.gen.cs | 31 + .../Enums/SysKind.gen.cs | 36 + .../Enums/TypeFlags.gen.cs | 94 + .../Enums/TypeKind.gen.cs | 61 + .../Enums/TypeSpec.gen.cs | 51 + .../Enums/UASFlags.gen.cs | 36 + .../Enums/VarFlags.gen.cs | 84 + .../Enums/VarKind.gen.cs | 36 + .../Enums/Varenum.gen.cs | 276 + .../Enums/ViewStatus.gen.cs | 31 + .../Enums/XFormCoords.gen.cs | 44 + .../Silk.NET.Core.Win32Extras.csproj | 1 + .../Structs/AdviseSinkExVtblExtensions.gen.cs | 246 + .../Structs/ArrayDesc.gen.cs | 81 + .../Structs/AspectInfo.gen.cs | 50 + .../Structs/BSTRBlob.gen.cs | 50 + .../Structs/BindPtr.gen.cs | 65 + .../Structs/CABSTR.gen.cs | 51 + .../Structs/CABSTRBlob.gen.cs | 50 + .../Structs/CABool.gen.cs | 50 + .../Structs/CAC.gen.cs | 50 + .../Structs/CACLSID.gen.cs | 50 + .../Structs/CACY.gen.cs | 50 + .../Structs/CAClipData.gen.cs | 50 + .../Structs/CADBL.gen.cs | 50 + .../Structs/CADWORD.gen.cs | 50 + .../Structs/CADate.gen.cs | 50 + .../Structs/CAFLT.gen.cs | 50 + .../Structs/CAFileTime.gen.cs | 50 + .../Structs/CAH.gen.cs | 50 + .../Structs/CAI.gen.cs | 50 + .../Structs/CAL.gen.cs | 50 + .../Structs/CALPOLESTR.gen.cs | 51 + .../Structs/CALPSTR.gen.cs | 50 + .../Structs/CALPWSTR.gen.cs | 51 + .../Structs/CAPropVariant.gen.cs | 50 + .../Structs/CASCode.gen.cs | 50 + .../Structs/CAUB.gen.cs | 50 + .../Structs/CAUH.gen.cs | 50 + .../Structs/CAUI.gen.cs | 50 + .../Structs/CAUL.gen.cs | 50 + .../Structs/CAUUID.gen.cs | 50 + .../Structs/CleanLocalStorage.gen.cs | 61 + .../Structs/ClipData.gen.cs | 61 + .../Structs/ConnectData.gen.cs | 50 + ...nectionPointContainerVtblExtensions.gen.cs | 240 + .../ConnectionPointVtblExtensions.gen.cs | 305 + .../Structs/ControlInfo.gen.cs | 72 + .../CreateErrorInfoVtblExtensions.gen.cs | 279 + .../CreateTypeInfo2VtblExtensions.gen.cs | 1340 + .../CreateTypeInfoVtblExtensions.gen.cs | 859 + .../CreateTypeLib2VtblExtensions.gen.cs | 589 + .../CreateTypeLibVtblExtensions.gen.cs | 428 + .../Structs/CustomData.gen.cs | 50 + .../Structs/CustomDataItem.gen.cs | 50 + .../Structs/DispatchVtblExtensions.gen.cs | 1159 + .../Structs/ElemDesc.gen.cs | 90 + .../Structs/ElemDescUnion.gen.cs | 53 + .../EnumConnectionPointsVtblExtensions.gen.cs | 248 + .../EnumConnectionsVtblExtensions.gen.cs | 240 + .../EnumOleUndoUnitsVtblExtensions.gen.cs | 248 + .../EnumSTATPROPSETSTGVtblExtensions.gen.cs | 240 + .../EnumSTATPROPSTGVtblExtensions.gen.cs | 240 + .../Structs/EnumVARIANTVtblExtensions.gen.cs | 240 + .../Structs/ErrorInfoVtblExtensions.gen.cs | 278 + .../Structs/ErrorLogVtblExtensions.gen.cs | 226 + .../Structs/ExtentInfo.gen.cs | 61 + .../Structs/FuncDesc.gen.cs | 160 + .../Structs/IAdviseSinkEx.gen.cs | 228 + .../Structs/IConnectionPoint.gen.cs | 284 + .../Structs/IConnectionPointContainer.gen.cs | 235 + .../Structs/ICreateErrorInfo.gen.cs | 258 + .../Structs/ICreateTypeInfo.gen.cs | 718 + .../Structs/ICreateTypeInfo2.gen.cs | 1074 + .../Structs/ICreateTypeLib.gen.cs | 391 + .../Structs/ICreateTypeLib2.gen.cs | 515 + .../Structs/IDispatch.gen.cs | 866 + .../Structs/IEnumConnectionPoints.gen.cs | 243 + .../Structs/IEnumConnections.gen.cs | 227 + .../Structs/IEnumOleUndoUnits.gen.cs | 243 + .../Structs/IEnumSTATPROPSETSTG.gen.cs | 227 + .../Structs/IEnumSTATPROPSTG.gen.cs | 227 + .../Structs/IEnumVARIANT.gen.cs | 227 + .../Structs/IErrorInfo.gen.cs | 273 + .../Structs/IErrorLog.gen.cs | 205 + .../Structs/IObjectWithSite.gen.cs | 227 + .../Structs/IOleParentUndoUnit.gen.cs | 391 + .../Structs/IOleUndoManager.gen.cs | 460 + .../Structs/IOleUndoUnit.gen.cs | 251 + .../Structs/IPerPropertyBrowsing.gen.cs | 255 + .../Structs/IPersistMemory.gen.cs | 237 + .../Structs/IPersistStreamInit.gen.cs | 253 + .../IPrintDocumentPackageStatusEvent.gen.cs | 29 +- .../Structs/IPropertyBag.gen.cs | 417 + .../Structs/IPropertyBag2.gen.cs | 789 + .../Structs/IPropertyNotifySink.gen.cs | 150 + .../Structs/IPropertySetStorage.gen.cs | 386 + .../Structs/IPropertyStorage.gen.cs | 611 + .../Structs/IProvideClassInfo.gen.cs | 161 + .../Structs/IProvideClassInfo2.gen.cs | 185 + .../Structs/IProvideMultipleClassInfo.gen.cs | 865 + .../Structs/IRecordInfo.gen.cs | 1361 + .../Structs/ISpecifyPropertyPages.gen.cs | 153 + .../Structs/ISupportErrorInfo.gen.cs | 153 + .../Structs/ITypeChangeEvents.gen.cs | 441 + .../Structs/ITypeComp.gen.cs | 828 + .../Structs/ITypeFactory.gen.cs | 308 + .../Structs/ITypeInfo.gen.cs | 1928 + .../Structs/ITypeInfo2.gen.cs | 2546 + .../Structs/ITypeLib.gen.cs | 1303 + .../Structs/ITypeLib2.gen.cs | 1609 + .../Structs/ITypeLibRegistration.gen.cs | 360 + .../Structs/ITypeLibRegistrationReader.gen.cs | 161 + .../Structs/ITypeMarshal.gen.cs | 789 + .../Structs/IdlDesc.gen.cs | 50 + .../Structs/LICInfo.gen.cs | 61 + ...DLMIDLItfDocumenttarget000000020001.gen.cs | 4 +- .../ObjectWithSiteVtblExtensions.gen.cs | 240 + .../OleParentUndoUnitVtblExtensions.gen.cs | 449 + .../OleUndoManagerVtblExtensions.gen.cs | 505 + .../Structs/OleUndoUnitVtblExtensions.gen.cs | 272 + .../Structs/PMemoryAllocator.gen.cs | 23 + .../Structs/ParamDesc.gen.cs | 50 + .../Structs/ParamDescEx.gen.cs | 50 + .../PerPropertyBrowsingVtblExtensions.gen.cs | 284 + .../PersistMemoryVtblExtensions.gen.cs | 255 + .../PersistStreamInitVtblExtensions.gen.cs | 271 + ...entPackageStatusEventVtblExtensions.gen.cs | 26 +- .../Structs/PropBag2.gen.cs | 95 + .../Structs/PropSpec.gen.cs | 91 + .../Structs/PropSpecUnion.gen.cs | 53 + .../Structs/PropVariant.gen.cs | 1600 + .../Structs/PropVariantUnion.gen.cs | 1593 + .../Structs/PropVariantUnionUnion.gen.cs | 1544 + .../Structs/PropVariantUnionUnionUnion.gen.cs | 905 + .../Structs/PropertyBag2VtblExtensions.gen.cs | 1034 + .../Structs/PropertyBagVtblExtensions.gen.cs | 518 + .../PropertyNotifySinkVtblExtensions.gen.cs | 139 + .../PropertySetStorageVtblExtensions.gen.cs | 447 + .../PropertyStorageVtblExtensions.gen.cs | 768 + .../ProvideClassInfo2VtblExtensions.gen.cs | 179 + .../ProvideClassInfoVtblExtensions.gen.cs | 150 + ...videMultipleClassInfoVtblExtensions.gen.cs | 1104 + .../Structs/QAControl.gen.cs | 94 + .../Structs/RecordInfoVtblExtensions.gen.cs | 1854 + .../Structs/STATPROPSETSTG.gen.cs | 105 + .../Structs/STATPROPSTG.gen.cs | 62 + .../Structs/SerializedPropertyValue.gen.cs | 43 + .../SpecifyPropertyPagesVtblExtensions.gen.cs | 150 + .../SupportErrorInfoVtblExtensions.gen.cs | 150 + .../Structs/TLibAttr.gen.cs | 94 + .../Structs/Tagpropertykey.gen.cs | 50 + .../Structs/TypeAttr.gen.cs | 227 + .../TypeChangeEventsVtblExtensions.gen.cs | 542 + .../Structs/TypeCompVtblExtensions.gen.cs | 1009 + .../Structs/TypeDesc.gen.cs | 110 + .../Structs/TypeDescUnion.gen.cs | 65 + .../Structs/TypeFactoryVtblExtensions.gen.cs | 345 + .../Structs/TypeInfo2VtblExtensions.gen.cs | 3236 + .../Structs/TypeInfoVtblExtensions.gen.cs | 2397 + .../Structs/TypeLib2VtblExtensions.gen.cs | 1971 + ...LibRegistrationReaderVtblExtensions.gen.cs | 150 + .../TypeLibRegistrationVtblExtensions.gen.cs | 373 + .../Structs/TypeLibVtblExtensions.gen.cs | 1580 + .../Structs/TypeMarshalVtblExtensions.gen.cs | 1098 + .../Structs/VarDesc.gen.cs | 135 + .../Structs/VarDescUnion.gen.cs | 53 + .../Structs/VersionedStream.gen.cs | 50 + .../Silk.NET.Core.Win32Extras/Windows.gen.cs | 60551 ++++++++++++++-- .../WindowsOverloads.gen.cs | 28152 +++++++ .../Structs/IWICBitmapEncoder.gen.cs | 34 +- .../Structs/IWICBitmapFrameEncode.gen.cs | 18 +- .../Structs/IWICComponentFactory.gen.cs | 40 +- .../Structs/IWICDevelopRaw.gen.cs | 18 +- .../Structs/IWICEnumMetadataItem.gen.cs | 112 +- .../Structs/IWICMetadataQueryReader.gen.cs | 30 +- .../Structs/IWICMetadataQueryWriter.gen.cs | 60 +- .../Structs/IWICMetadataReader.gen.cs | 112 +- .../Structs/IWICMetadataWriter.gen.cs | 248 +- .../WICBitmapEncoderVtblExtensions.gen.cs | 34 +- .../WICBitmapFrameEncodeVtblExtensions.gen.cs | 20 +- .../WICComponentFactoryVtblExtensions.gen.cs | 44 +- .../WICDevelopRawVtblExtensions.gen.cs | 18 +- .../WICEnumMetadataItemVtblExtensions.gen.cs | 142 +- ...ICMetadataQueryReaderVtblExtensions.gen.cs | 38 +- ...ICMetadataQueryWriterVtblExtensions.gen.cs | 76 +- .../WICMetadataReaderVtblExtensions.gen.cs | 140 +- .../WICMetadataWriterVtblExtensions.gen.cs | 310 +- 216 files changed, 147712 insertions(+), 6856 deletions(-) create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/ActivateFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/AspectInfoFlag.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/CTRLInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/CallConv.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/ChangeKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/DescKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/ExtentMode.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/FuncFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/FuncKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/GuidKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/HitResult.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/InvokeKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/LibFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/OLEDCFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/PictureAttributes.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/PidmsiStatusValue.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/PointerInactive.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/PropBag2Type.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/PropPageStatus.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/ReadyState.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/SFType.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/STGC.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/STGMove.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/StatFlag.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/SysKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TypeFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TypeKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TypeSpec.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/UASFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/VarFlags.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/VarKind.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/Varenum.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/ViewStatus.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/XFormCoords.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkExVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ArrayDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AspectInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/BSTRBlob.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/BindPtr.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTR.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTRBlob.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CABool.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAC.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CACLSID.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CACY.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAClipData.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CADBL.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CADWORD.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CADate.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAFLT.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAFileTime.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAH.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAI.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAL.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CALPOLESTR.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CALPSTR.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CALPWSTR.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAPropVariant.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CASCode.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAUB.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAUH.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAUI.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAUL.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CAUUID.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CleanLocalStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ClipData.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectData.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointContainerVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ControlInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CreateErrorInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfo2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLib2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLibVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CustomData.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/CustomDataItem.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/DispatchVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDescUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionPointsVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionsVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumOleUndoUnitsVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSETSTGVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSTGVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumVARIANTVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorLogVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ExtentInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/FuncDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSinkEx.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPoint.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPointContainer.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateErrorInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IDispatch.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnectionPoints.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnections.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumOleUndoUnits.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSETSTG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSTG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumVARIANT.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorLog.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IObjectWithSite.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IOleParentUndoUnit.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoManager.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoUnit.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPerPropertyBrowsing.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistMemory.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStreamInit.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyNotifySink.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertySetStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideMultipleClassInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IRecordInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ISpecifyPropertyPages.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ISupportErrorInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeChangeEvents.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeComp.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeFactory.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistration.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistrationReader.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeMarshal.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IdlDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/LICInfo.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ObjectWithSiteVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/OleParentUndoUnitVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoManagerVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoUnitVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PMemoryAllocator.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDescEx.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PerPropertyBrowsingVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistMemoryVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamInitVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropBag2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpec.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpecUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariant.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnionUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBag2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBagVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyNotifySinkVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropertySetStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfo2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideMultipleClassInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/QAControl.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/RecordInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSETSTG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSTG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/SerializedPropertyValue.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/SpecifyPropertyPagesVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/SupportErrorInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TLibAttr.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/Tagpropertykey.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeAttr.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeChangeEventsVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeCompVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDescUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeFactoryVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfo2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfoVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLib2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationReaderVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TypeMarshalVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/VarDesc.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/VarDescUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/VersionedStream.gen.cs diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz index 80f25c634b44afa4001f63f418989834101bd35e..1db1c95495c5e953059d14ad8e1c23c23bff7304 100644 GIT binary patch literal 236147 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

LJ zDTq?qDw;h41;yGsz=hcG zk3-){G$QO16Y&1-1&ze-^i{FgS!Q?us%wo5j=K(!T~=jI*z*dr*9tZf?0J@!%M)1* z2h)}b2Vq^&-x2W1X0up%zLX0>_~;8lkA}$*VLG!tkeT`Loxu=eP^)k5Ymv^be%f}r zHY>LLRmfq@qu)%=*zG(yPon5xykWx(6p?w$1f~#_7ts`8{N7)7RdCt7vT)PFQ?2$k zP8xp`NaJ_Dc+uaTO48zxO>F3ml*k5!F~SFb7sg}}lwTN`DCLbakw^+m0PQIlx;Jp} z!hyDE5%~c?&AF4YVs1#wir3`VptR}iONB-v;K4{UWEdAw0l1P|NP5Gd1t&7t4(&wU z@@-Rlu+!F~?&UZ6;&=DSCn2g^a4ik^`RYv`IFxyl9}~jl1)hZiw}n({({FX+t7AZi zm#`Ms;eB`3CE7B?;?;~U${7|OBgc(<$;)U@-`5A{d zAg8312ez!_prHxu2 z3Bm16ZF^%jUTQj&erd-J^jq7MQR{;)cd#Wc0D02LS{aUn(^513 z0y%*K28DXyU2se&93~4Qaebr@6p&S)vA+Z!@+_b&z~~8!&oQ`q9soQ9216pIZm@{M zpAs{`C}EO_&rP@CQt*=juMK>|>s7B;d|RB^TG*VNb(&m-we#nl<|fS>+9%GTfjHOW zFEnpjw{@;*PB4cZIMvJjfv*K!&`i>*Gx9@V#MDt7JPcCI>bHDog$rkXtlen7b)>JtDk z3^;rq;9sTCDJn~eS&I2NxI9L8{-2rI}7;e5CGRsxTyK+If_VDbCp1TnYofj1|p$RKQUd3Y-ixD*A3 ze=IhL7#*O>C)+$74bl!im~F;nQ$h;#>xdIDTtVT4;`VyPy#ChypZi&_ zVt(ci>ADwq?PPq{0ij0tib%-&wYJQ2DJm0|jft8D;yn1D`a!eLr}~@iHL+^xssxke z(701@0~?|_`X{x58_U)Z!GFB!Oar&A3*>JS4eGiUzHTuT;*WLxA;hQZ(r@-y-(aPY zEz={#MWDpAatB8E&3d8GqA*(LzIfjFP#fQ)^_;Y5q{C?tIRkQN^#G%VXx>O>%wbaP zwB8*=ru0n+sJA3Z!UjJG6A2{|LxT+_1tnDw15yn@CW%7nZ}3B}vjVQFgy^Gg`70ZL z#&N8fL?%GQ08f=`+d(rR6#s}3{(b`~23MG$-ee0mywB0FoB#@oG5Iu=^T}4*quDe= zF&t+p@?PbVv;8<||DV+FmHMJb|EYdQ4Fy-wdh(&i&mza!xL1B>gMGKFs~cqY_9>U! zp`wk>7&p915h2(vfI%TKb-k@Ypb7&yy@_X`lbDvEGk2m!k&3;R-t+U+0Ow+wvhQER z9Lsgq%4Y}GZSO4_{+o-YsK^xZ9eLCqND!q@&AGEY=DhU$7cQWw?6d&k@p=|^2q=#o zE_rUDUsTR|{8fV@$kz3sUbFc{p5CV%t`6*=M1(Pd*t`Q0a8xN7@Go?) z@Y*={cOAU$PF)Hl^h&C0+-j4ht+C!S?|kKv)o%jRR(Oi&cs>tP`d-7F-)0 zHyRCqeEmw3A=vy3NYjfqs9d@$VAYV>e^D#@e^9Hsc`g$u`!)c&~9dsShkpNf;c!%H;4e(-xQ)@P^h~1cc?1iC+%Z~F~P2T z3#tR~zyy;&!Xp8YgM%2ksIJ$VQ#W)&N2|Yrn_ges?%Cm)G3TZA9qccgZtJ_8_r=H7 zcg{%q=6%SC_9!(;s7Vami5-r%QK% zkj83`NF9Vead0B-JSc5oGWM8{(WfL__}otjq23k6xq7k#A*H;a4;7e?GNg4o=WB!7 zISYa@kf$RPi(LUxlRr9z#-(B&u%7RYtR_DI8rDjG%l)=Tvw|-w6_g!*W)8+EFk)Q4 zcnmEvf0(xh_1rv&R3j0|h$hO+AucO*1-5TATsAq(so zlr3;MY>(`!XJLEA)%$%{;7I*S#;R0jQ!m?9^O$yis{HjH{uFc81AGJ{L<~KUUbdZ0@juqG z4>T9PtnEzj5jp0W@HZO`8M%?0c8he%|GWONQD(ouk|`=34pC1FyiN!agc83*?TRoW zKq5~Md?kx03L!=q?pr65_=TWE5vzzBppF458D<50R(K_R+>^|zAlB&e?=B9rg4an( zG$40K^?r^3&u$?Bn!=P>AroXQV&q+Y#+d<{Z3Bb)SgbU4AcQLz$kPhNuk?L1p6^mg zpVD3u&1iY_5%jhrK5}{MK)YMN{=K_3SQcSbkp}w>;h&NKANx{e(hLxp(>oNvE{yOv z4SD2h-Bb*?ay&RWEx4a09>osH#O5Ek9`Jm1TsEQ)7oDjgWF9>*-D2H36nU|m=tGXF z^SBLNcIH?L5AYW4hc5*fDd_{2HM;r2O=OwC5*|x%Zf0ms<(uS9M`Au#R6s3hd?r}2 zPI#Gluk%){yEeTU3aKVPfB;PC>nSNXrInvNMD=|00M;Entdl`7!bSi*gs@9=e_mPT zx~VoINn1gCJbb5iwfaYzX?-#t#!OKO07yh48{RRt!NVZ)wx*tM6KQqxn^MEwObD4z z!@hi=hSxuipazj)_s5ejAD*I=qjVtP(^UF;y$KJ#^Fr_$F*)oqUv1NL6iB6GOfIP1 zDLGNZDe~eU2cw`~5*rs?L<#D{ z2)O(dH8)hKhS=v{=^Lu$W#wFe^7ayQN?&Ods^^3>?)P9LX_@=7$Sk zHisfUKL{Zd7w?gnOEmC+dkS&+&+A<4{e#g z|IkK791vFqj4SI1@Fqlb@lL=pOuq6^^0-!U3!;JnC?$BZ%&LxS9rp*O8PrAp9=2xJ}>bocKMV0u&DbW`~LgjG%Y`E`^w}O743`bf|oE2>8lN zA)Fo>&4b;14mMiJ6DKiuh!l|EZkxwj6m+|wEefapV~aun>L;G;?Dm-!<2>4Akkcc@E2W~h5jFi}l{-C9vnm7AFHZ6t> z752gLj|&)-8$6x^Q??rRy=vc}w*GYW+tP@ZRom%AsN4JFa7N0;V#0cHR z(-3F?GzM4>9>%4@1M2Ac+}`0H98bGWkS7-+l*TxL`?B%NBVg*n>|E9;+OK!w1S0Q( zjTUWk{~|9XzVt42-4~aC*A>)02l}Um6|Yc;A|9OlCJg`yJ!ObLC@WkKU!9p4n-?77 z(sFU?b+duU#>_eH#2Hn?4;QtV441jls5&YZD!^$`Oy0F7fRUKAg*~jsumaB|M0K2OzCQTCpy1Oq9_DeV!vWc>o-U z`h!?49A`rT0M$B&=xx3L;MKsj!tzk#*SRmwwEP5lf=u=t$e|$N{?dF8l~Rt%TC~o= zlE5n|k6AIkw}FWo4WQ*fEQJP0S)ZHE;C!TU7S|zV90w&S&+ZowjbrCfNE9+xtb7?p zavDh%^N=~rMB%zQA(WK?#sbYHa5^)Iy&zCy;$BTd%(UqQ2b}Vg>5I?oXjJZ=X*8X4 z?Lo*`GLTsX+GSrEbKmT@DaqQc${eZmcF(Nooosj-s?FEuzvGMjACx`+EbPxk?^tYI zK96zb^#X|GeCMGzVag!TtbUV0NE$=Ae5SV-Eb+;J>1YrG5D)R;N=VHz<4NV6yZ_GN zPfpB%9>(e?Vo9SfSJp_L`YGeYyE~&U3{q!lvm-lP@8h8jRn2g@>(|a|2%v(V&0k5K!R5&>`v;(pNOi4+> zXTE2@t3dy zpZgCpy*IWNJw*S#;cK=xF%>L$Ga9?N*E!WTA_fp1MGS-rYVtH1qxFnk7UbX704_qcYD(v~Nl-(U@ z=e@A+p0`<3dCzije(CYSko8WYDywD%!ibGyN)hxVc;q`WJtYR}<9k>0WPNe%>T{JI zh93QeO{<qD)Ls;mF7Ja+sy0ab8PgMt{3|=1=S^Vr-5?vEVCyZ}J+exTK znYdC>5=UeCP3IF$mNEEcaI`w0_c<~nlKmd3N(BGi(|V*m&kG)KIdXx;x{Ztp$XTg_ zYQO@N^`$hH_4D%|(ZrVZd#l8j=sx87g*PdaY?uNwri-_@?vQqc-8Vj2Ajx$n==v=q zu1rQlU!Av+SZQqP+kn)XaiiQw$4=5x8YeE*EjcIXB6^bjP^1`|%7C#F87ii^65(%>YM=8OG;2jug?`O5K!8zm$no=O-q+DbEy8fbpl?ZhRZu?&M!w z+~ISlt5UqbKDZMNyMgXuK6Iz2r+?q+iB^?VH3)`8DYmWJdmF%O@-wrY9XWgqAv}u!EcNr( zi}w_l3D_*3>HPMFo28xy?@Ip8v0XXyn1cJoAuhjLMrHlJI%<9F0u-2n&;m0sqhVOH zm(YY8aT#&Bno^%Zj-VPlf94d;_=#wcYAAN$y}+%M-v?*_3-kX#U{RmV>kpP@r)OD8$aGL^+?QBo(ACY8Wk+w1U_PH1FYYf_nxlv@GTb?L}D#WPm0rG~jj zC`-ri3porJ)~^3L`R%F8S; zoP|UtdV?dDp@DN2B)=q171&yUwvDX?lf_7vegC(k+N%t4;7cb=t(CdrbcDccugC_TP8iRe>e^LDY*}G%-p6>XV z0QV3R$)8OfN+ZriE8-WLzicl2XGh$*w*+P}7tf1$JA2@aU1LvXdick;8UmXl0F+U9M(p>?%v;6X(>|6CL^=`^w z>Cs06Zv{*Jyddj){j}GDG&l~k@O=b%($)P%!eqA3Y+`J3tuGmPy{=g7Uh}%*wD=T! z(CYUIbm{(nHPv~G`mAe^N!00heI*O(7MsfhZstfa;Log9aHrtZ?E!VJ<8g-+EHQA$ z#hzCmSc1;NGyF1GG}>gkq`)w2_?aIoiSA@YdUxT8{Soa|5Q-b`M_+V|^T^Fohh{4`JIu{4`pXBg@_ zJVXP1w!xEToNwo2RyI!yAYIkd7%iY)8bejDj>APt$q@7pVg4E$GESfk5ai@Hf(4sHOa zUh!q$d}Csb7q1lDbmVu94%jdgFrVi%2qf1`uKmF4GYd@jkx2A@a~g5y@p>7Yha1Wm1|e+00$By*ChBu{l5$ypYHP@RC1wB<{3 z@q+eNOh<|ZW$KYrB*n})GQt2&ri<8mHD;%jBAhR>zyl? zQd!<6`!R9LE9UmeEQJmxWo#r4CV^8jV={*ZI3*@<2E5{%4&WhoQfCXFD}+hXo1eg~ zVXirqz$^(2;KYgp)Lh3yl2oQ~^#1xdw{%UP(g-fCciHWH|Nii;Uoy*{k3<{g*?dv- z!i(7Z`BeE7U@V(`(>64ju9+;7xVad7lVP`fXHux2KqBt7?y%#3r4Olprw`s4gFZ)p zo15V&&haDCUk1YIfFu@zc$b3pHIJa1HvS`pRJbYVX@_LEljtnkF}MK<#ejbceKGmL zi`t}g%r(Vd-#jI5HU5@R#Bwcc5ZHhYEYz2|={WVbP_l54DJHTTH3MP`sG$mwgZ#pe z%P+1VzYtlXO*nXhVbU5DyQC%B- zGya1N5v)t98)Qb%=*g5hYJ;|r-OOm=B=CA~{TH@lHMVsG_Xha0i*QPl;E$5008;Wu z2mY@PeIWhN2EI=IF02>>C8*rc%bJDuHE21>TWhD5K9HSBELJmNhI z_EKA4)!KQtZ}6YB(R}g&%hP_FObgPt3Kf!Rjz_BTxfYpU{-KeVY~m~X-cOjPob`4M=ZA*5&lHGLXI8{Lz%R?u!OVly_t0APf zx&08RG{09xO??WB{Mg#9f8Wj^WT_^lK|<^26<-z7M4D=UGo9^xL|jSIaW?*)l-0Bz z4}5f;)=r&Fdfh0O!NO?aO4&~-SiD{Zd&6wq<1_#;Rd)6^v&|J1#giH8}vV$c}qLJq5fm*r8g?r zZDw2;+)})XB9&Lf9)zd*rLxR+lglfz7YP2z$IwM0xZbBA!~NIKX1gr4b^a`up5c-J za|6^j$9RRG+?>8cG=G0T#Wf(6C9mrK8bwDgdpReW-57?3n@dvh_&!nLVFkDM$_upS z!g;N4j^!CNw!KeOZY9C~ui&x`XgNT1>0_4%K@b{GBQ=E1&s;vKv--+5EHdD&%p8S` z;&%sj8Pc|}d<3Z(Fu12QfzW^gVj#_1miUqv$t)q?q*a*D&@04Pp5QvgK) zweC34l1gB4d{-ifK|Oj4GKK81-ox0ZEnzT;Lw@{sU53|NlIwk{b-A<~n8KOM&vi6M z=E*_UG1myYqqw~BLZ>PT%o398KCsq9?*?7S!$%z>uhGbxMXJ&47*%}UU#@87WIEqL zX%un(TiKr==_=GZx>=1)v-qzN>1)3brJ;g`anV*GJ2_F6iQN{(E*$QN|(_1<)2T^;=L*d&NNN~ zjR5A)Pd-ppXHzEFBZ}k*(V1=?Oo&4$`eYW-=0i zNp!NY@XkA>SO3`CdqN!S?PclYshvLD`XZk?H6}B4G-dM$_3s-$9Bz#6{Nu(CqB<`5 zoF}&x5PJ2IqB^79tbZ=Lk^K_VH2o0VhHB}Vb8=qzLBFi!n%iWN$0#-g%*Lb$Gvs?q ziIR<0s*}dm^J>FTubAe{|EE{{j!YZxS!+VJ$e5w{rSt(Fi68CGy{t{P&m!-Dw7#>F zSyspK7k8fusbre}Cl)<1@$3ANVRms|W#NW*sqv@R@<$DFg1_r14E7c`i?0hT2o~yo zWSD!wKXH}je?X&R={c+K%pkpNsL0Vy1*B9Q2xy@f8+~bJ?+0(o&Hu>?utmM7`;cPC zDt}li%gm{k6ausBL$m-*$a6lq`zOR^A>)U$4*Xhq4iFT{4tZ?)*?je6Zy90rWh&PeP(~5k&D8wI)we+oW620@F~!0f@`PVS+TUz$u+N^dE)}@ zNmx2TNKG=!v&R`$Y4wZgY@n|XTxBtEQ75mW-NL%}Mog)D|H8}OjX66n(B1dw*ZtSV zbw$Xy4}N&rT|OGBEbkt@TV`J_v6ltz(8kd9f6z%h^SX2(B$3D954Jv##3x+GBo=+g znFamp>&l?D?&4NHx($l78!?^{iWX8ps$!KA3*K8V_H0P;3b24Xh+=8sc&O=wO&{j2 zeA(+z7whEdTv`0a_}fb$Pb{7R4X6MT@abQwqKM-m(FrT1cRloKw+Yx0UHoP!YD(;Rk zXFqiRryg6+;?`yz(y_&s3jMmM9_aRXGbAAS-s*?+m+|ew;aeDt5+Yg2HyX&nbNl=h zd=(J0nK-NA@-3e0|~?N2vZ-0I`Cx5p*XSI{Yt4sy|7A16h4$> zAa3W^qKL2^YU)J6F{%Bp^P7E{ffDe~zx=K40X@duU(R__k zoa|EhrxX*U|-@-7tmPS|p??mYI!}FGgIqCItOgM$pgs{2eDo>|%gS zL`&>8WR@FfU``0ib|Gn&Fe^7m4$cay2M(-`vrmB$8fiR$))Lx9F&$UGPk9-9lD&0p zsoYpo{L7Gk>>C4H{(5VKd-ZdxvY|!7$tQpZK=O$X|Bz3J2#`)Btw3>n4ao92Jdj;C zsA7P?{Wh|rUlJ!v!jp#P1hR@x_)>6*f;8*kLr!|EzZb|e8%eG7Gt&OZpP44^Cf98U zDeHHXp!JCRz1x~u87v$Hri)UL4W-qq(%SP{6ptfQDi#p2$Awj(QBMjx~C9VC!c>;!mthN(p#UQ%kRiK7} z#OFjx=Hi=@=ujXFCx-JXlCnV+S?S0_AO(+R$(KdKKYq!fg=5P66S0l5JLHatUN$?xd?UjUjpF?ApvM@BN3VSIOV6OAtciVnH_Y8!8;M~7?TbKEY$k^ zhO>7(%$(qKp2#XFBxqndYpNUBe8W7DqbFhEChJWI?NF$Bb39Tbi-ANJbQ1ZiWx=*E zNFxP_If?=hZZgupyNAGy?u`;2cX3W2rQR9i6s34DR`||psK|uMe_5=b7qHld1mOvT z}j{ueB`j;(DP>FA@d*H-I(wXhW1TC~8v? zOMkX8V=l498yl6s7eBaZ=CZkiPX}?`ohiP>BVi#igCUMvWwr{|TOmQ_M-mevOTj@q z*Ipm*+q;adZEEV>IGFPD^e)b=Z5n2ZX6OOkV$HJsfWjpW=j_kcKQG_zd_9 zQShxhyLx5yw-qY;m=z?HLH=sxz|S*rY`KF*I7c4KKnp&!M5DB$6_8U(o6QPa7c1RO zKXyPp$ZUo4A&%^~KoBfLx@4|WwhOL3i7L;%feZj!d9r3Lq5VL?xx7HWzzE;6II|ax zL`(!%DIoOwgYEdT{zMz?*H?f=)qQ)@f*=ftgdi~EARs9q-7~+cS}fo`;5Nt{eR!R-+k5tXX4B`Ywx{kul-y56dJ5T_=r|!7eCC_%S74hQvVv0 zqBVT*n~R+IGp{f?X6VErz`Z@tP|zh1Y^KBH482C~5f=kh{m+-HYU~o5 zk68N;t)v)~dvG>Mtlc;-?%25MFWc+^xQ_iLCKKQIW@aj{I=o^!)vC{{B(F0-yPc$Z zAtbvv;%k+ZmDyPU>-w@-{R0%eekaqv%1Q9R=h=ZBXszaZ3gJ)k=3k(ZE(-vgbw0+h z_5`r4pch_P5#ei|3RtaD%)+}6d}uu(%n-QfeE=o^o!Ih?NtS_amF{V6#tI%xC_<&Z@mu5hVv1%&=vtgydNC{`G& zgyGOLaBW0l{snKTw8NQd?b)ss(^Ue#km3nQe0T-l>(FuurUU>Hyvrta7-bly|5Oar zi+&K=BEKXNrv%Wf5F&((q4Gq~e&PiL-^1u=Q26sJnhlIm=FC0lY=ADp7ZU34H0sh( zAb7eq8{|{`k`;~qs`X<1iyDLh$$|hN0?zl6031ZwAM(05+*{TMVxUk1jeMyFsz!#Z zHN+kSg2Dr6SMna^3YmoB|5&}wZCzp&cjgZM2c)ODj{#sN$el1;@+Sh2^`UfD2K;?( zVJ~z534L9@hZWF6NEaXi1$v1PzcBhv04&HZ>;NojEYZ@?ht-Zm8aC78dEQvBUI=|( ziF2S2tCEkw5!8tp4{V7%7<)*aK;M*R-cmyTa=Moo_6bxe%)sX@nSqlDJKNxgnd^tZ zU93xfez?@cNc;ChVC{ePd_*d%67o(M2^gzCkTY}ENEd+QYeeZ`M`WyAI_~P2pT@y( zcMY%Z@Qf0&1u=`mKY9qM^`wvOJp2MBM~~_7vc)d%pqOB$!Cay2r<`H)Nf6;}7+k63 z%7A6S{z72>L^6M6nf@GT?S_@k%nAa*e-%I|Y!Y9w|KhLB^wcA1ArxL6I+0vqg^I4E zkVdj0A#b+yQFk^>h|OG!M=?b08+%07?<`#U)qQZ^znv z6h5FX=c+a99el8rv?X3=hOM1+ZQ-!rd#VX?|ENZFI0 z^v6_9b8(U2(DGeGgpeA7;M^RMNY#20zP`18WpefVazScbf!D_&DCkF%$tBD{z9+wS zI7@wN3cFW>0SXlJ$Zxz$Wy%)mkLhhcg$r7IJ^_@<0k)T1`VTTZ;(;6zpAr*Dc>>H> z0SiMXAwXu`XH{AV!r{c3dbnxTk)5o=g6j@tO!>!hR`3JM8Tr?8em9^%(4bjxL2V-h z)JHeKec($)0kR`z#~-hN%v2zwgVSkTuCz($5khe^X>W&4Mi(#cSE;A0UvU~(w(@o@ zUVfb}^H0(S0JWz>oV@Xb;$M@t_B@oHK`1Cq5sY<`8$TU7GJHj3kr|Yxm@V&Axw-8H zjZVFrL#=G>5CG(h+=t-?k z@7o6dl-`255ilhh^>xs!y09~X@N*pq1}+)QcDWfFRFPkoxVd$^UkeciDQvHzGNBT$ z35y=r66H&(w8MZZI!v>bo{$EF_xwX(p&6Rj_#6^LfX{)xB|{UaUQQgEBS_bU{d*n= zKOsx+v*!=YkNdMef{z`!^O6u$ob~}o(=oraxF|ubAE!>BS0b1HTaHB+7C z&%0$&l)O#senm>Z7lyq*0tzaHQEZZ@-76q>|5=P0R7#beB?|{wBq&%VMuU4p>ass@ zISi=4fGs_YiVD3_(?9wL$$xOXG-{@OeVF0$LcN8fqtIK#XC;qZ*Mb3tOIMYaiAt|z zp0}iy9y+D)peFj%@WivRW1sjvO`=d2hla~vJyvYu*<_user3PYpO^nNq05-5;|0|{ z`X2Qlb>t{p9CWxyHbqZ$P6mUJL#Sp(Bk5x>_)am6Af(d zu{)Zfl8+DE)NefyluPP9d~(z_^XtaVBfLo&Tkg{i`)r)RlnZ~-1bqh1>uHYS`tE3) zyp90k50OE^5uaKBWd!EUJVF_n&1KOWDS@z6V`QQa zr&J9BZPE~M(g&@b7dxveCV&XGmk^cWf59LOWm`Jy$~ ztqkiis=$!Nfcx47fSnZ5SVeZ+2)mO4A1RO0^di)7+&vrZQEH(l%eUAE>{) zJ+;6}zHs8ARb-;BXsnIaZF+cE39bYejb?}#fjVkl9}`0fMq7me9+u7UMgwt49#Mr8 z2}ANbiG_)Tp|6Br3Jan=$4GwxkGO;Zos^B4P1Fd|$o|2Ttbxo%SZoMA#gtA2gRTqn zP}D=KgwhgD+I;~DNU!@#oDS&DHqeRlY7X9@a{|XoJa%u}&fh3B>H4)9xPGv=*|r*c z;NbGv+SjGD?Xyo#!g3nN_U7bp!O_vdg09dF35B#92G-`uuOh&6G}O{IzRuK}?LWAz z==b|K*w=i`QG`7?nI7Flq7;BZ_+Rgd%uECV!^I%{@xAmuf6{kH?>%+9E0)t<>9Py{EpcxrBmRc;mhGak)7+zy^ z9sXQ_5 zPsgs%(K!JzK+89f;kz>exticHN8~MVAUO=_ldwyk?}p-3ztAXWv-j1oqUYc=2pYsz zG>~Fw#P{b+KhgwZGKPM7_?8~e-s-Pb{Am2!JlwIi=k;-AWrdGqncMc%EH|URmGI|2 z*VNa0$$X<=AQ?)e z!Nn|@(ROc=@-MvGhuW@t+JXj=fjS`{q@0a8z;me30eP~50g>mr)1!C!y&{^Lo&xW( zsvSV7jJ!yM!~r=a@Ir}%c*)+>0{4WWkCd6e=iZ0Mlpmp?-|jl*0(Hs!spvsapo~z) zFvVWf99&hVYYXOqA!elx#5l;KN$F3aV`>%V;akypyH7blYrCP7em;dx031DhXM%6!bE6Jj`J%k`R`qHpEhT^`0KSdntRTr9rmf(XXU4s89Ue!cR#LP;&{3DVZk2p$oML#Hhmg6@nb5Ioq_2Hk7A%2*?+Z= zdsf6J8ugQ#MN-|@(%G6>__(ETovcs&)9C}hvm2up0k)M5X-U@?U6~IS!rZf&Lp}E^ z_Nhp3-GnTGVV&c4N6fvvvtPL~11Uo>7`0Zo3WJ7+nv4e0WsWP%0T=Xy6A2YIFoapd z;9&>l%~u%0Ohn5VUIk;?B$1HHuL(N$cjP68oh{~r#s%0*J!DO;RR|(RE;S1$@I*)t zs5&FP89KGx&Pw`M|L7JG9Gt|kO{D+VE+7x7qY+K#_0nmWpe53--; z>CoWyFXI0dt$?qPg(9Q(21^M)3z8ZfJ*Zi9{bqCdTlJT# zaQUl@cr@Z&XTD4UMIaSxtJqKN!jG4 zVF1RCPb2`dG<{9986IOFVD=?aS&SWW2pHnIFAiC<(q3QBbvmbNTWjW5e_1Y)40d@= z4^y^x;O5{AXQK0-0|(9mOol2#9I_cx>+FFT z7x}5`bAo@|z=>ZACSj}*srfzIurp#FxNK@lNYC>kLl8i+Aq&ljXJblky)BV?yUD$N z)O5CS0+xYe9J-|jtRLfd6%AnA_-cM=0*yjPef?v;AiFho2YjKy(e(x>TKE@ZV{|4p z;?v3t(O3ZvNV_u`&IUkgMo>g4^cIYYHSV(EG8v!POvaP9 zPNOY~-*F(eVEV475`k(x(tS}?kZZT^@KhPH0rQ)-vJr|P5tb|{_|j{w>q}8FwoZuC zT)vUXu!BqjC!pSo(xc@y{bO%;41m2A#fd=nmS9J~H6Z!pvS`t|v`4Lsrp5<|xd7Xd zZ4;TS9K_+|A)a4jTm(uJDCjBZJunvjNzgC6cN@8yxb%>3F+kb7Q7q{G_Uy9_d#GI$ zV+Zf^2|D20`+#NGf}OWI@}Kr_-ZGMKRjg}QbZX!6Jj~k=K6>ndqZj*F{No25)f`=q z&NF%Bz>mxuYL!|Bu8B^Gzz?uz-gt>wG57`h6}>TxvcvC(X4i}W8-7GJDo@befzF=` zCW+Jsr=IsHWec1D%p#fqPlRAa3^XwNsUkFh2wfM*^$rECr?H~7o&yuvLu&tlCIT1E zdIoqRTXK8IP2LD!>ah#dej{xK4|m0E{frQ+1l$(%36M=gb^ zLw)LsZ+ITJQJob;v!KgiJu0AAD_S5f0OKs+vy;!v`wa~B2UJe0iCH0-I$+?lm|Dd% zpntreVs;Ij>y}N;b)4LTNy)8O^F46p<#NgW(-?uBQs>?=AJ^S8!wyoA=f5=T?SD_8_ zkd1-v>qIG?jhTBPAH)vK;rURq1XLZilQ4cCJBw4FJuk7ztx~#ly;4hD{;u>}ju?(V z8p3hw9}UU&C1ybHqQYC5fkOexQ`gt|Gi({oH~y3i__?OVBFOdhyIr9p^v6~-VnQBB zDjq01@MKi{%9lJ^^s|I(Fo z$wCevV^f*0c7tVy2Y2Osk7_o4Pi@WR$twKLiZxUK$%OmI;cIYJr2s<7VKt=J6wN zh{m%cr=mCa<7%%R^UBWGpN;hJl$~7KbYUNO#Q5S<+@hZo$K1@1xqQnOxUP`;3T!}h zD!To74G1%TtC3G`=}zC&WNC%xTZ-!&3TC-tN-IfcU=Z0+I%7=zJ$;;8kjL#=fuG-n zX2+Y>oBtf`(RJ;YpWEq7aI1XTLzCsZ%E6nHY)st(O zHkfz97=9HP?Ryy&bFLP0Yd9A#BUu7A>0ci_=?>AEz?`3BFp;i<=yec+dH>j+coz=uB8X0dLA#{(^qo$KYyM2I@VuX z@)h??`MI}DhX%bgd^ZGd2wub)z#J=(OqCjf*-U!WuY&vaPTt0n)4$63p`P5&&^u7d z-Z~Jog_H>N>ZfC!%5pB+&&Vc`%n9yQvCSygG36EXs1T`$Q?=c*myB?|SM>1m=Sr`w zO%J1Nt%GNDAN5Vk?RxUL|ISU_uebOV@BiM^@NuY`EK}Sl>jQ#Hzb*8?3Tn9>RZ>`Y zJ~zG~reDPlUJ-4I`NJwVM;x-^gSmZ*X_JN^@XwC1`b?KU4lpM4TCj`daNqTl@ZxHPttYd;wXjSqh@|J}Ec8}j^b zs&Arhd_=v{<4%p=Z7=q~Z0q#zD%(K`0>S)Hp--?bMt|3&@7EumWWS0nU$9di)aF;*Hv^tw%0gqF@aBg$Q2~s$E*Q@^CQWR1k{+RVn5I#3f;m4_ zWqxjy^Kxc_@s5f5As`qYN>O`zd#$;**Zp>%$J;c{$l0zmBcJ*gQ(87qdsWEoRj4z9 zyHyD9#6K9y8N?_Ew&Mi^HH6=>c1;999s7skF-F|~AxzNC_xsa;aPgJ$;d6ok0Zi|q zL+r^B(1rhXO{hoXnXZ^NH9dO56c~Du_3zzoB;J3Q6!kdQaPXz$*M!LxU?dkfwmfGa zcfGRR`yuWskfwFByq|;S__h6InE?-p6(ix9M}`j%I0t4r?Ps@(mk-j`$B%z+=g5xC zU8Nm=6uMa+CE+$_eq*!#Yx7Fu4ev^Ap3q@8wa*hEv$0+3BSyo~o1G(&`#sY72~!1X zoX>jCx|zS=ZaGI=+zHaO>9RiDnHcCH0DvTp6Sa7C;N~TAN+WV7yHc3^`qI%n-8y=9@;B~Dim1fKh^6bUFCK}t*BJRKCj8y`Qt`pl^2`aSQ0OP$l_ z-K#jeO|Bufn@@d=E4Kyv%0VIvG}abqEJ1mwb1c`_LkZ?_4u`enE6)n<&BS6$d!-3i z*Of)vP_d>*xzX|x9dkYD&k63T@Wh#=+x$9f*>)Hxr$ zX1N+tdKtVLO#m+ffP&)7?KS^VUKMI=`y-O7U-A(j`&HIwX9o92yB)WK8Uu2;?IYr! zVe~^)EHTe$xr@uZjNTSWvfaD>WqIGUY;@SZsMdBwe#X^YZ)UQyr>O@_Se?s3G9ifR z2}JQ9KXVdZ06`CmXK6_3X7H?KHJuZn5u_0$v@(S056NI1Pdj;(3q%Gl^f2^x17Fo0 zGg5wC&{SoSa5C84tiHGXm-goFqVGJ z$K7zzmCAPDwcAZE18s0&3Pzm_Wuz5UIO1iuu;F77vIc{}_`>bzea5uU(~mPozEe!& z^&mNB9M?$2%E@6VBIu4?}}W(UtKW7<`muF23TnZYj! zjHmc+dbk!G75Tu8x&$i2P>!cS1rv>+#%IQJrjTejlt-I_eC6MWK*f$Pcs&_d8a|2B zmq!x&_2x)B`!m%eGEgD3mnyQ)yyt_Q25=}q=x^KIw$n((>6xlr6s#&=D@PVM&xaJS z*&AeB+tUFtj&08=Bgq@14$PdsadhkDjFQKNUbtR87dm=i>T`xhaa2IY@+Mw%L+LIc zbinGjgLnw2j@~V%d~K{2w%zqQeeGXu%wnLc8FH@gnULbx63DaMe zN_Tfrz$`G*BiRL$X)~ z_xl{xSRjpev#8an)v+K^lEn=&Hw5i-C-#G!7_})c<@uEBKwbh2l*V>~CtUW@W%P?NEHmTeRdg!yQZlAKc z2(}u3_FeQ&OOZKVFqS4G!GW9t~(PI(Ujr-?Rmo6%F`*Tp-ksYT_CgB zlM$Se({RXN-jq|u$Rcmo-PEPG>w^YtVEai6m9aoH31c-U5b;zI`n1tOIwd$Q2WcWB zgOyA9*Z>!eP&!nn=y4}eEP^?w6mE%X3yC|0H)(4KKLYRx)9fPwKH(ijmohKc zgD-?QZ)W_4d>{SihK%*@GHicl1n5{7F0n$+9WtLLzMV>-GmBX8$C7PPey2tK?#kKNSkKvx=V!^b3GZ3{2Y zUQ{)bVf3txVn>v-NZ*};WpKYq(p!e9M|^`rmiX_ePQ#CmZQgFW7F3LZiMwIpqdiPf zJcr<=U?zE>0$VmcSvkjcA`8pQk!4+devapY>BzUwL!65kL}E9Uwrv{%JSg1q)(%Fd}g^V>yZpq(QKo+|$h8EgyDmu?1~V@n%=cP4!Lu^S!|&$y~yma=EEYXUZw6Y3)`V{J4N z3c4P9NkO3E^KZ`hjhnv4cC>1TZEfw$1zi`n@BeGP&z9Q&p^Eu-<&`pZifSNm11|BR zy9Z}z*UK2Yhl?F>oqA7H1P@JyOsb$IndcFgX0Ih}-&a&*=}J>9K2VUB2LjM_G&k3k zsTgr2fG3em4DL{|f|o^`X!`g5js?5afka#sW9}i}(a6YtRb%&ba{*74(Sg!%w=3Jl znz7M*-vYB1u)LutA@EICp(U zCbZuq{yZxvDIT9W)$>QYu@?BGe^1Ntn?D&!(#iG{3VYA$%n3}m#G5WvcD9+gqi;ySoC)Kh7cPF@I>O?52`a75{0`#|J z6S+Yd&=(a;z8`rRzgp)%A7oYR?v zuP^18uzKOz<12SsI&Zs*etp~_G;5kxb*s&5g*o~9{`B}iGA~eHNTWvm;2`aoXd5kE ztE0W~hI~QeerS5?mX7v=^*r@ay{7cg{?l`&&N)TRPx_J;6Oe z&8G)U-J~E5b@v^myc{6a?XCWptu3UWAjV$x+o^btc#dH~H7m6lrAqbm6LVoHBbwid zKle0$>gdUG!>(UzQcmtZ?HkDAk$ImY<;0A?`z?;=CuZ;?0q$+lw#dzB_ZGRksc8b6 z{S1peu`V=UGkN^a=@oKVNzTbB(SbV?$t!8w&^dpjWk~1gwFl`i!Xi@!&pex<@XVa- zhpy9>VsmmLbRDFd4d4K7!G{uh-hrBd6Rth~$-(gYx+E@zr^7z_&%FT)sokR5y-g$? zr)?#{?Kwp05<@#;x1#c?o!3rT%!HM)8gN9Pm?Cyp;)o7yBi)Eoayq{ObB|$i@2sZ> zxi6EWJ=4PjteA&G`}2cpSEB;3(>}D?B5hru?OWkmQAM}hSLU^vd9!{wQoMEG{6J^l z^z(zX%}0rMigxI##Y%O*q%2!yjoO~sz#abxmilKN>yj#y!m9ol$|MM^Kg53iobsjT z=I|kZ&Boz#$31nckCF2PGl75~gN+P5ov%>S^CQ*V@JxG=o7WnFbVqmN92`O-NxGtSTX^rr5s@*bx)&OTSht9c@J_K#OKM!NO#2k2M{VE} zTcRI8b?q9j1q_}Qbo~KTqD^>`8ABzb;o+x-bKwsgXh+pt*x;@L2bxp=Q5(mOA`o%S7%-bkjEDzDntyx;y_s+`!K<4n3a?UAb~E_h@=`{99bg!Nk~iwd&em zFLhgRR-KM{&&*5WH%lMOds**U;zL)J6uY0=&>n&Z;bf#?s&7wST0`x_52JlfDp_hM zs^Wd@!Z3=hCYGE*-tn9wKRpf)AK$C(2 zRBTLx_VZD$1DFq`Vi3f}iC-r~DqWZ+-VkI%Ov5cokJ+qLua-1DkC{@#dihr67m zbi<)br2BDKe)Wv0e=5KjJXtzzm$Ut7@T>IwLayI&-xp~BGbLS$8twy3ihYR6_hiuX zo1Tgacjwl)5|wFpf4TLG7;Fm;QMhB7o_D}QSekR(mmk~kedNscF#F*%v*(WETiP${ zpL49HIR4rbIK~zE9M!VQ8`mViGP5r~yF6-@i!>>o-&h$n8LurM_sN^sJCX@obWPRe z_uj@tZMjH4d0PB->S)`%(zRB0G_doyy3csg#njcPrqUTKHKz&hd2o<)%}9^!IsISh zX8TUvdanV1WpUqQej#FF=ChvmpKGmInuF)ILI#?HBT+5B4z8bMKd*Ftn0rz!HZ^Jz z;q7`MH>6Ugr}GD_d%&c-z*(AUSxe~g@z9sBM^!R>ZyB$LKbTTlS)g%ygh;{U-pIW% zduK}Kp1)HHpBUGxPMjo9@BD%bIMpoW^;IEww*E`8APrpO+mXbp*|DZb_`}WFr z@Ao^m=Bq~zs}Hh9>r6OqSahaWFjJx_5Ttnjlc#%Im8h1YXI|<`1fC=#@mJ!4QIe6g z2Kg)H6r^*LC@aBWWMst8n21^Lv0o#Np`Z@-i)U6Gl&Wp`aPkA~xjk4JikZ9DPs#QH zjFQnxQp%r;>nedLc{2h^vQG;~D)~zUQjihH0^xABt}0IXG{o?Ee1hHa&KE#f1*aSbb$%-XF~YyYtICXLcoc z$=BcRoC)Ljf2Diyy;B-;muvuO|Hzx&GAUN|Ne4|9E@9Q$GA zYB!lUAE)@Mk0BRYZ7ZXxdXR36{#s16q|qATnXOI&J;=&}_0N7(U&uu9oe)v6x7c2Y z)|ii`Y7M&EWZh)F!J-gr%9W${#zVg}I=t>d?wgJA@d@Nfk&WO;oy|J1Krw zMU?MM--PIdD6tmN=@^YAsV{dKWS=$PC3)U5-7>AC^>ZxQN!m|?80>^j)reGUTsyxb zTDc^tXw4t1J)G{!oG`NgfT~Z*`SGUj+}(Iv+5Y+K<6nig+c!nuT@dNH^yZvs4{wM4 zob~mo>>l6ONiPNJ1>E`=Stuz2{Ix1V{GC?1f%G>T|A+Js8)tt=R>oe3;bWsRrN;_q(up+ldL zMafjhFmri5Rc}Y7+?#3Ay-~ShPj^>lu3hTdp&JYR{5j#o(GfQ=@nOKkgGtY}TD6aB zMv`p8Q})@-ZSyYSgfe#(^}3;Lt2+_FCt1a<}{^0gPz9y`={cv zVd{P{#(J$z$XCe9>+7FIsB*}7@%0cR??_cqRI%;Y0_`f-`JGru24#i2?~_L zFc8O-#KAOG+Qv#HBVUs{sL31tqTnUg%v7^Y57N=&2x-=B(j|#)KnBIM=)TB6I;@0b zkX^vn;A=8s(Y4~-4{ycvhsh{XB_h=>uTB2qt-OC;(K;fAAp0>u_V+dKm!a!zrL?tt{T0UQob9Qpfl1gU8|k3436@Vb87z9>OzxqwKE*!Wh_ zZrI5NyRdB{O`(nwMV_}PQ=;JEQ~Pv8=;MrIA|QyON3%KtBt)7XlDoc?N(YJuiey|Q zu!GZ7$7{#v0LAu*F5jFJ;@l0$29mVfR3cO*jEmza@30?faho5fIM+fCP)G3NINhV3 zBOZZ$ldIYL{0{^)0Y5)DcOkZ7@VNwiBMRAIAL;JS9(S|md!W@AqOh4z^ zi34Ka25_Z)(xW)7@bgD7Up*$@mvk4P_4|M4FeP7azx4I}>kYOP(u7yW1{M^`ce)OR zLKfep;1w!8K3tYHdy;k3lP>u*!Fp!T=eyhQ{GM+&gr|s)8y6kC*6f@_6%@C3iZ|P8 z7i)ZnQt&ih11sh1Q=8lF-wzMynD*eK6t0r*!ddfu*N~j6$ARSLK0inj_85iVzgSkR z_+Pz&GXF7gHuYnia#dWDIOas}nV(#NE|<7QQJ0*L~z2fk_F$t0a4szRkn?DG@)lrzI@V(+iq);#`gL92}K=_>yE;5$&1 z$_H#)q=z8(*FN|?NYe%ae;VSo*aH@lA18K+ef-jX`lWp%wX7Vxde}Z*&z-O`MYl61 z@ol+6^3-%oTw1_vErL(6L0jaR@fa2m^)BB%VWuX!CDPw(2Wtm$-J68)f9nB16#g3% zBJvRH5NpE4H4Ql%)}bhz5dRbZiT^JhprQC5TmXdIbW11@ptr^OBY#JGw29pIs^Sz=jYWps0~K|Rus z?w{NT4dOOOr;%Z6UhFM~R5H6ddzT)5t%SQ;CwnWjE8Zzc^L13CyC!TMp71xd9Q(`J z)qm&pwcU*P+28!!ug5(;sd{W zFeud77%G`6)v~#2u))W+wURo0ypFd8*lu zYp=xJ`5B0Z4LD%g3MsG;rwv5jQNekG&Ghoj$pU$?I{l-!sA5jtiL?Sl5zxy3e6!dv zmGb%?B(dXj4FgW*({Xo>uKfs~=#B`&dMrSzY?o$NgzmY0QMZc>e4yuVv!tCC3cijs(q34{1uE>RfkpV-NkmeH8P zf+9S~@3}uqW}<(%mF*ph7^DMkt=*$T`$(DkT%WvdZ4TR zQq~Fm{KSx>zi|TXA$TzH*g&sBKbg1UgDRgc*2y!kIrv^maai{W8%T84Th}(aJhDzH zXOrC;zfOOA`y*rfah=f1T}$_#kBobCnd+^X>Vi637}`m}_h;n|*4)JB98J!P^K9(K zo$_#{TQ3@qKk3?G;(1vczqwVk%C^5X?VgwsMzZzcF>YI`!yY4ZhGnO)pTsa-@vLnC z^ki)H$#d`3Pgo_sq;%k1g719jKiwifmD;~_IipTV;M1#V^E~-mPX!VH8D$6=K8Vj+ zjc&{5O=`TRwKTB|5g+}6F7^!57K`ZFliPVb36mDKLXl|U&u2V58&VMl<$m(Iu7N|S zCHOCxCr(~R+re6!Pv_~FKVFHhD0C3Dn6b@!^Qp%xO-E(vK8&W|kuan(Ma@XSzfm_kN zv0l#$E#_gEn^^oq_@5{9k=-6AGq#oF@j6|H)s8aG;Xn6(FAsWz$sfEByVrSRu<21< zYDv0!b!y3T@J|P%H%YgnJurZCMoscof82MN8ElS#^Y{=R(mSVi} z|7IK=_?;Kn$hLrCP@&7M=P8fP_pVl{oA09D6`w8ovaQ0g#aY9# z$ra}t2?1B8@HEBO_TJ@88pX!0?`4iuf8yVHy?%7tm4eI{xKpx-Mb*wpH(AAnEK>eM zH|6u8{cML5j+jt3kPM>JxlY*?*}Kg zxOwwYH}z=7=BW4eSYQEla*c>AVQt6co&>)wOZSPN>P~#>OR5{(r4$+co0-`dZq>b}~W>isZrzqG@_+do8_Y$|B!L@A$d@a|M z*B#R*XG+zh^Alj-{c6BcK;5NR33->UFL2MP@Oy-PHY?{xn@2NGsn$>Ne$DQn-q2&Y z@kKJE204;Ubcht?+p3awg}EyN~+ zgd3M|3-yLYH}yu$g((!o%k=y#K2+~lbV43~(G0n(yLk_vN$%a0nA6qVm7g3ERMO=y z3uiD0heyQKAWuui)nIB^HZ3|LE(zQED@>8QE1SpFa0&YdlzJTErpP(1&-UFfjCOZC zBMg5_>a{^YLeqVTLV zExmDPx1aM0^CM^x`CjdRU@Zv!G=$YuPO_%)3|rkCxFEftc}JLdnEE_&BlD-~$94$+ z?-gI%{D|cR#j{16lh3OTyg-5n-h(Ot#aM#@GVu*r7WFYZOw;_X`IbiAnY7K-A7*{M zY6U%G4-mpF*ytf>5E(DeEXbC|l@CpgNqytjubQRu z^3n*oEBJaO<~{XFK=lnD)?akhlhugrg2%b4S@GbjlTy4&-&CQluh{1a)E2m78*JZC z{)mtMk#2B?hSSO1L`wlKSNy+3<#YwKoO)v;$UUL|@`A5%0o@#2c%I#ETWG~q9Z!P;k~ zmGovybS95_A)qQ5Qv-M-i<@=+A zZ9OcT)zV52H(QsbCx72t+q3Yl52yJ`I&R(NS$}qCY+=?@#$)ZqPGaAE2+#MrFrp9} zcbx$=zqj`6Bg~U;ceVKK`njK#WDJr!^P!8d0HHm3@L?KCU|I^j^SM44**?uMj-fYy z*tKV!I%#^JF2vX9-Psg7dA6N`)e~6*&kkCms$&={<8co@r}Hsxkcz}*SQBALe(b@KMyDUiPJ0iWcQkD-$gz4 zT)vVOjbA?TrrZ4WbM1c?^pZQ{>IMNsf3O`a=@m}C_IZ;oP=BMGocoygY`9xYMn;pG zs|_#6p@j6JP!%7uGN!(LAwp$mtQiT2kkQ~n0s=Ek5xqK2M&g!~EElaDW8_#xkklwv z&DkUJ5RwNJw{aq5)ax|sG|LI{*lXBcvAA+ZxCRrL0EGC#Z&9+4{5f1qDM%3ca0#jL z@_FQ)ydRAzB8*@qF9hUm%y2?z=1l6I;9Kx2n1I1dBzHZGK;5VJg24oUMN{T2f4=su zP{x7K;Zs#Gz!fp70VWcc?JBc}ydVOyuau}DcoPh8f@TQ_&a{A^3PC8ti*g@b@4uCY zyZcL{T2M1aBL>_d1BW39iGdG3l~ke1;Kxh=ynC^k#ND46&p{ zc0rKbvV-$)_xEgK+=UFOcxx zR}UPMd!3f3e(+#&xj^lnb8WQs!3p7yjdOkOEidjwfgI77BG>P}5&#ikn&y~oEziH~ zF`J=q%tAm{*n!f2j-~CL?}7!%!XMTPT3e-_&de@4t%??pRCoLi9c8^SYgpaKkXHP4 z7@=t2B6T$W>%FABk8|Sw1qkKZ@?0%aG;R8zZ+7jsTk;iuFNw}|?}sAZJ0{29*lgD7 z-yQXDKlUaU&6Ra>xGMCr*m%FBpJUb6xXt(Q_A8)j{002N=5qgo$_m}pxq3u8$gs+O zM=*^1KG-LouW1xlA-8<-j-dAYPGc2ue5`09JP~eC+Mi%x8Z^jW5m#I)r4Iyn>a(t(Y2)9U=h)Q>9U|5 z;lC8MtMTw@K_{Y)+l^hNF@Lw&jTdhSjbRD{hy&Z;T@2PS5_{3KDVphw;6>Bt&Ea3K z21wuUk@bUM12ZDY-2N?sJq(W%xyukbOhwIv?FoC<+@|f1{PD?%;XMph=R7+Y%hd6?(MAE$3OO#IsdxG zxyX@etmJ3nss4ZV;LN5kc4SJnncZt<8%Rp|(EYqE5&&1od_itW#hS|6+$6%(3|2s;nx&duWYkRb#1vofuzJ*rH1M@fctkW*No&L0$CRxqhf8p?!+_-EfbB@o@ zxv2f-#YdjmwUvhwVsB?ZVVAnMX=}d(-rY$*mh$ZTvk)X<$>aNe=WUODajorcotA6X zPQ5M7u=LW^nQu=#J>sA3jR+619k)mPlRt{Td5z+qm9oF930=oin_xr!xMLzxa@h|e zI=YBcG;u?;jY{*k)4%<^q~jED0W2EwMrW8w7s|Re{<|h-Amnsg{f!Jmtcg2 zAoANMo512#7?iGN0_p1Re^TsRTxY>`>XMQFeTfO14wCHBUe8C z0ZO;Qo&HI&qq!(~nMitJybMIWFbs-odX4-}vGxEAb5`qYBv{H)Wt<|cFTtq5`cN)e z_PJ31&ovCXk*d=AH<=YL<0}1lUO} zCC0xgSj1?t)2&8HN+R&7oRa7*Di1#>Wpb}}Ov<--xqj@|Q-xoj|D+fBt{)y0h1JU!fBtifG=D|>>3ha37iSiYjX#|0eGT9q z7=tscREJJi3PBPr%~)9_8ivev6+^l-a+%6*3u6|UJcn92S85-We+N4WJP(XCY~;?s zDB+NdF)cAc7!~KXM>0~*E6Bt*8I;esB`GKm-Kus7p@I$w6_S&wx#B)4v__qA3^jh9 zb)SM-j2#UN2y_bycWuv~I$5VIpaO=jJ;*CaVlk$#ONFRIss3H0*6qsN~#3QgTurlwTcX68~JD_Ma?*%>&1d+jIN}5ax z-M~EMTQKnQB3@0I20_7XesOSt(~{?K|NXdp>#?U(@0WV=|65F6OY0Ag{DILVZl#-G zYg{Wn(FrEi-<+uT*<`)?y+ED)ZQnEtU8nVtf?Ljba_0+VO$% z$8ris<%jFX)xL>FJ`IMC)>RAaSDqYkSRS)|k(x@-zIc4`O%y=N#U=3ngODQBwmvJA zojX+!N?j?w$$8@i{Anpxtk!L%m&VCf=tRAE?47L@Ewq@zfwMK!dS~HBt{1Hz@5}Y2 zum)Q*SdS)tFmbhdv!W$_`iqNYo3(<4LKzcpTA~PPW(P&3XpY!u;)<5*OWD2@6Lad5 zFZhx)5-pQX#ePAHaf?yA+_6YBz7QW~StZ&W>U@;OV)XLH%Ntfrl^yN2)z0x&K5bTs zRA5~_nZ~)(@l(6A_=z;IuuiI1CudZ>7yW5@b17=?vP^tP#66Ek!KU-7%yfqy|A(-* z0IRBN`iGS+De0~wEh*An2as+Mq$CtUQM$Xkr8`9=L=lkgZj_Mj?)=t4@B6vm=e^(m zcg@9Fhkf?hd!4ms&6+jyo0+G!z_EUc_!%%e0&0>)O4oF;gG|A<)z!oj*!8ug4JN5HawIF|-R%KL`X#1=aOJ0jB3-LN+9 zZAl~%`fDN56=W3raxI!$UUp8TQkNfMNwwX0h?%Kf+ei(Y4R~RUBq2|KoK;4 zH|_19cmX!M1z(hNd8H1#(BFNN>!XN09z{n1NVLD_6prs)Mj)>&e5NdWph%#IY@PO= z#peBUAG$WWwpDO>$=Bgzl9)8eQ9j=@IJ?D)md#p&CAT}oGBtI-B)%!1!|@?&p}&Xx z8W~@H@d2`wt_3>^1{wwXcPdzm0l1tdlWLiYJ&+GZ4ELOwnF&0=rGQb5R1!mOjPx+i zBf8-N>cCDCikTOY>=W^u(RF}4MCW#9?@pe)|Ms`LWl7ENIqTufsGP_Mr<+Lm*J~86 zqK{=1h4pC<+xK46&xT)&J1#=9-Y`ib_ zH`xA_o0Ej%ZsxKuTr-}=7JecpG%E=CRJ|L*$#?SE1vgUx@$?IQh^x}WcIwzpsXfZt z2Yb*Hx?gd-a*p>1>!xG8wxMrvQ)AO((=RR0I(0KHO}ofsoH>Uc1u1@|pN`pvp5(ZE z(tmLOt*ZTgr@r9khjQAsVRQOHXx58gub?k+-@kog9P^>mqEYV^=fESz$Bd7Y?j(In z@!~XJTZDlp-{aLD{ov&4}Yf6Pv#d8`#dR z@N4d@igb_red=cGR%JlP7n4%PQCIJIsD~w0@*5i&0^R(N+k-{?eW~#Urnnc4s>-uH zFLg;K8hpr|;J456@mlMoLEh*BUSi@5hTQ3B5$1W!yHYAV5+e4AfyymvEoun&dl{u! z#?)eM+tE5J02`|!;N6uH#ZkU(qP`-CM=cV|M9p(`a&=amJ!ST#`BFhsVE>keA15_X zQIb9jl=uGij^@FJY~m_4Yw+zJPCkWG(=l(C1$BHoMj}hsSSUCeT}T%XQY{g@*Sv|8 zio%d}e=rD^&w5rmBQPD78)lw}N$iCnD+sm;oLnM;3{?mb?U1)aOl0Qz0ZSmbKKXSJElz?~>@)X3}eNRlpe~=bBjX_VJ@6 z+2x*Z6)qgtuxAjm2V@Jckxz4SGYMTZuUZZiV*J4PBNE68b(?5Plm_HMW_SW(-VGnW zJPNoH{3UQTt&TJeg1!3pl_u9$#5-3Tlf04`=l+<-q14G$EiPIwE(g*iPx5EWW?iL+ zGmB;RciR_Up5u47ojoplocLk8gx0|%;M#>*#kS7GaO>)=Ic8tO@vs()o3>TNi3rP5 z!}Z4zve5Im(YTw-^S`W^Y~68<1<~)2K}@49b(Y<=kE80jqbfR{QuKyl_3BtqR8!|d zb4>Ruce||nlf^d1F?>HD59!Aqa^U%^?`yP>8{1-5kYe<;N{JU&#l4`b1VXX}4cFN; z4hfg3q}YkCQ|vHu!0lG^6x03u56$z;61BL}LE=b&N)nd_^{zM~`lhEcoInnjacpk} zOqgQd%2YgR(E{}`d~an&LGf}<6G3rmKcu8`Z>FpBtCm?Rf=mFGxRs|sN&#I!30qFr z`;ITo7E%CA6KJ7sxfPc*^HkYtw2f3;957iGtffoM5#J^Z4UN+Pt2WIqps||!KpfW3 zd`^A54a<~Je3p~=%*Ya*%O?!!EX#8od?*l5Izu``KriQ>qOIKjK`p%oyD<&Q9`YVC zOfHVR9I}+h-Zus?Ckh1QMloA#vfD;E=_T_b)iu?XPY=-o7Sk*JabX4k^$P|bZJ>Sx z-pb2HvCdAhLU;{c;LEoK;_)}(Z^vJG@f9Da?|X^$h!uM1!B&1E1SBt5gQs$DNPqzs zV@N=DCnK?$tJioVcWA9KVi#VqVHJkQx%jcG&44=TG!tuom zYZN0Bw~fr=@K(kt3S4RhQ`!ex=(no&fFs_ZlZXtDfg}F#`7Sav1RAo3EaW9p5U-7u znX|zE{w)BZu>uga=Oxi=rTkNEEOvxNm zLHBm;<+{{j%QIj(<#TUx<_H4h3{=h~`v+j{?ON_7f(Kkyi4~2{TqrB{moE56C7j2M z#$SkDj*iD?{w%Nicr6+RjtfJ&7knC*wN$4JV;rH;QG@ z9un|mnCIFHWvnDDNnx#adSE}1qj+NFm4#{%ZOiWT*5Zwh9ydMb?Zd}{J$&4R9-Z2% z6m7L;+!HjscNRUKaW<<21 zjsSw#8rfdTUP^L3(@5MH+~GcKG^WRNOXzUkhZsX#tAj2`NhcIz1TAFbT4=z-DjT?m zDAoABl1dkw6{scK;YdIQ5yyAK_Mu_r2Cm}Pa6+X799kscGIl*cl=||1G*C>81j&*J z0TF*}RTN$BSwKxT*tQsAGX}B&!c#ZE=8lld7Y}7+NUnc^hE_F%Yy6v(Bl(?{SG66u z7*S9-HD|P)K2V*pt46-no)ma&N%jOa8Y>16v$}QyR!D=GpcvR}(980$h$#)o6??>{ z9s)@17@Nq(*-iDQThD5GC2*VxXCq%w?c4mC#;p0XGgL{M=$d&P@3do;N~z0Y@A33F z0gF8wYwxHcecY3GMDy|)ipZ@G&C&gN+R+~$+B@dUA49et^@zf$Uz&Qqj;4N)pjbU9 z8-!(8*gqh20vPCS;y%Lp(}hLTZ-bN+pAXnM`D;9KwYHzGT{Ulq9`BY-rN(=@){oTP zxaq8tk)6DH%IY281%`l{~&(g*wrsy1UUGMyH)(H7E|l@qwR z8-t3T&XL5f=hX>JPYTN%T7)r9!Cax8f;u(dO})92mi+D?EpoO7hQ=z8INgza(4$Gk z*{DerC1%=$_);>DmoW*Mo>U&Al(Nr+jtqx*h7-^y?bj)vF`}Tv#@!uMoaIu&k`IoZ z_(P(;mx2-R#_~9ltpkANh+#!W8d<`B(`fOBQ^U zQQ{>kv1FdIG=0@|c@ReO2XSd}>0!<%-Qv^l9Wf|;+AVY+P~WGeV2%uWVuIH($8mdb zj$_HnrdRs`Wz0G8bCzZkymR?>3++7NHjJcn9*H~xkgmGvA<`rf%L6mlUJZiqR_v0= zF5Fe$%k@lM3N8mze$@mJ*+xUoRE}u3q28OyYU$AasJWRAEEr=A+XtJBAJpKUmFbCsemk1o;KvCm=@T#&8 z;-C8Z2ADciH79u=KRZGK^|qHL8;l0dc1lIwksmdDx=~=p!0am({x_Y%FyY0&Y0GED zeIlfKlb_MJpZ5)DP&R84(0$C{cxl$ETsD|!%k978U(AwvhlbpzodNVLw!Pq>L1J>2 zXQtk&l4smQlh!Xbs(PPD@WByRXnV`MxM?L)Si-75KBxXCUg6d2L~BGE*FzjdmodTf z`eqgiT?~@^NMVes7qYD!k^E@jQ?gl!gsSJhY1A zmtI_zlA_3RdkvUBV%f-_FRx&$-Tg1X95LhGoe*+4VBdX$9Q`jLNYno_1Sy@}q^Kus zg>!rO(d7Tr9w+hq|FXy7aaLbZF-&!;PzOwT}Y1cDCo+0te0dKScke}6uD0Y*5STMn|%TRFbm%mAxKh4@SV=Q@6u@ zjSWp?u}dWt#K*n~O7bNZRA1hNIH8cyU_}L_ zDN__d#(WsoPCv{EgUBOWN`OHK0JW201*z}Q2oc|maB$TVYUoHBkP~B65NxN;<9h<;d9bx#iO%RV!=Xt%*LFAfQUAjhNuVBuU@UyDA z8HqXNBo{RXR+C)ClFAakQ%CFly8WxPbWlMX7NU>{5UtYy(Ym@~*jO88{RfDE%N@(M zH?#Q&U=bDrND6oIHMDkwvnvLcV$#Re7)B^ApUnx+>?nL*T;ZCS?k!bJN^r~^Wn;5y zxc*z?{wFRKyVm^LCzAYt1%0v=W3tLGU~_RIH1M7&y{B**xAAzB=jLJ)YACC*2zA?o zkiZEVoO|2Q5(e*$g--`ZoI2r?FGPsWAy4oCrG=g&|$8h%tZZo z;1lAMWTF zjR_CY4%aUbd{(`N_i{J`n?Ze@2|jFqidvBx(G;x%jc|%O^OUrO0a)N-BW^8+x0<4j zovog8^5EKBoBUfcAK$D-)o5%eOjUHog#xWiDKm#WLnIG{l|INPdVKTL7l5Ik{P8;7 zHkr8aYFXGSfeey(G-x=W0~}J+_xxz?W(I^(KfTq-DhP_~6}GeweJ*3~`Q^03h$@re zgbRv-J!Cqy$sro3BzsTjy|SerS~SeU^LO7Ou@fSHCVnw#8|)5aBp=q~c)3IrgDu7I zdMgYX2xa&h*h81&Z{V@k0Xg(krlV5V`=-bLWsJghz+@rga%C-f2Lu9}pK-i6I_M=6 zI>qZ3Z27Y+)1rLUpROxjaw~wIU(1CQpQH}@E$>5<&>z;5T`w&3E&2a!m;yi*`+S!H z%UAWfuxJ;;zoT8w*9HeC1p@>O|2r(WOikr4IJB`%?~?A8PHx&gr3mRb!s35y^xUH_ zkv~7LRNEZGpp^KT+-TFQyQz17RN-_;@)5kaNW$~GY`sg`>Rew6u1p*r*U=w?UHQgR~&?`K0ZhNF04(uDMjkbjI`~Q{jU*16?VQ)vYlQp2x95 zW^5;dY4g9m#F4+f#Eu^4V`Yl@T*}WE`E3O0AqFQR1(fzO+1Ix;2iOL5P3|P|r@`udqEF0m%ir zE3BcTyK8%hXHw2%?a6ExE1yI5=r0MpL|U!d5wBaO?t#MrrxKUc*PB;vsphygo``TFtuA(>misXLemTYtdF z$d^#My|`~2=$EJ!q%E+U{&n@&16Z?4bi2(bFj8ZfIp=<4s0yf(a+N*{TjtNTzbl>P zP;R*|)&;jL%ZdP-U72}Z+5!^#kW%N<{sAlimA#B<(X!r)c^Dlce;anja0cf-vdD4e zTN9lG@Ur>od#^eemt^V$mhxTk5*PSZpYMWDG~71fjfC{WeGeG6ixP(I639jlN#uIe z^T)cuarMq5?BoN%Stioz1vCAJ88_*(!=?Kg!-VE<&mSdA6s9|M0F1NKcaL4o9uuW& zj@y`I899ILrP=s!!zYSuDhc#rm3Y0|kauL{@Hb!oLS@W=$-MJY(e$BOi;_pKH_o7*F#I zt7Hk4fcS+|@Iq)6f+=e^`ncd9M=dJDpltX2$sNm}iW*f=>~lmrtP;<&vOp`w5|vaC z6s|@DZdwW5XmRJ;@_e@Q)U4Fa6_V(ES$R@VLXzVvpFMIQ>QnV4yW^mpB8g6a&rX}u zO9C1q86xiLcZ#+*EarOqMTQm`U2g4biv{(wPLqzfOLGpWr30fL3shT) zEEWcNJ_huOOdD;qe4UB~&lIV&KZRH!P2@qqM=Kjbjs5_%oi4)=UAWSU=k3Yl^w?Y@ z6)f&pw(-0n#c5Jmxm4j0H3<9zT?~sTbMVt|UBnz2h~`kVwcFx%`-f`H5~xnR@*{DY z{obDh%PiiNjFxM*qfSSb7%|ANQz;3_7jTC(Q7^G{w%l7{8DeRxAnG?3l;`)vx-E>i z#KJ2d>R5sxLSru0%-39bkJ%Vk{}F8P&A{NN7!9#3+4(m*gc<=jmkz-nihuhtkOlaB zpPbEM05}(edx2J-Fub0G8&VvwUzYIG58}D%Muk! z9OYUEy7qqh-AdMgL6Omz6B_ zs2hgmVrzbfo$MdG;rPZqwH18;%J_H3Te4i#H>dwd%V9l$gtP$c{bTtL^CM)LMBUjiP0{( zIgFFW*_T+p`a>%OpNzAQ0YCn6ZU>2f1)kJpyUx6s&Nh8OKG#!6eIA7_a}rJYQARWc$y5$ zR=`};y8YQKcNx*kvULfnSfT-iG*EF6gyxckBCZcC@%jz-5E4Xw>iG1hmL@_C%`Nwy zSzCh4iuErpVR+5Z)T>5Sf>TU$sLW>MbCvF_c&P-FDwaZvk=r|Fu!xkOQGDa<{~#b>Ryf8E<9+kEpjAbh7yYs(_Pw+^fCeZS)W25lLzu$BFv zpe?61-kTWM5WuK`)%q2Fg}Qvi0>DLF8iXvU9-~X>(CIW$ScaN?W$;*z-aR8cn(k~j zy2ju35WYED&Kcb~u9j)8U?T8u4mU*^Z;_p zG%_hB<+lQx7}%#C?`PvhC!f;#C=Stt5hapGhLggikkvihbX`WbmOWHzOQ*%z?{H*IgojBVi^1{ z*oB(k*oBpZ?X`BTe2=B{o9*SFuGa@S12KYAw8 zNZHCI#sv;}u;M{*`@-hGM05YT;G7Pdxyj=&UHK@G^g}&g>*YWLVcp5tbdvY8PzQafsKHzH8GT4PP;iw3l~$py z;=mJ!1|grU!UMLW*g*j6O8)z@u^A@(X8=$PU|le+`j3w5?Q2YPtKU*v=ket|!egR} zag%GWJWM)*#3UtgI`9P|m&xNfc0yZDorYlu;dkh#{OsuJsw%&bz{hZ#HR&ZDLKabv@y zAX&rOr$y;>Cju8Rp|h*&zEn)VtQ05}r`VdIRh zSjlhR)zjFKEhKGRSh>_Psw-&CpN=k?rXct2upM;4XSEg!s>V8{5~j@Rl?wd};OY-X z@_P74qRZpX3Qg)W+lM$Qcl*5TT6sI?^oe*ubQ5oazR*2xnH2PHnT#(3}36B{MHk*WGp@x$rrg@6c~leqLT4~cYaUG6C&L}2Li&}Tf6 zH9ZE75*kEEyad!27aGLT&+*4Q6-h+!@=nmwogk9!JGo)otzGvawGRYwxIB<5<-^ti0*bI7<@BTF$ckPln;q83CybWXfNXCNP-S{TN zX2JZB_35j@A^L88A{O)SNbLD{nmq5te@R5d{+>ejLQ)JqaUqdeT#CdfoLwf7wx{up z7(92gK08Z0yG%j|G1D_XZOnL|rDtCMMp1xmet=T#b|!?Ka*mNa4r9ualAfwgO^#og6wnp|3=Re{a@(W z<`c88r2ou?L*RG|P=O(5Q-!aN{@PbACH%dwWcL_7GuH!!Hbl-YEm`c(uxynQ7tl{~ zD4))y0ol6^#X1=wh;XTC!}SNTG_og56Y$58E;LPPx-@T;-X!e#C}ULxOu--HNtYnF zh}&RQ(Vr8dY%(H(7@3aOI4&6!Giir)LI4*g1f8u=)d#q+iRLNV_ST`Ep_Fg2ca9Ne zsru4@UvAULVtG@gBR3L#o%)!C;)wlN5>6;oNLBwgspKN)D&bU86wu?Y{}lmqmS3L+ zJjgDp4q+CP_uT^MYQWa2RK{N((8h{+&3B5AGWp^k>FH1)$Gb-`5*2Dmn|P$(Nm^!F z1K>HO$m?Ft859M#P1+k%U#L(Hg(_BIz(~v+ycM(X2C0&8B)}Ol|TTn*85d2}RxIHaM7Nm;rY_Q_tc>e5n z0G$B{pfi`odYIGK;Oww;{%1q=>T-2-3V>?2B|^q`c3wIkec;-sOHdlQQP48k_sHvx zrVm}#*@Ri?ebw#EZ*x`q3C@c+Qer;-8q@4B{j1+b@AHqJGtMSK9(w%3+b=;WoNdEj zaXZLi-6EXKRtl6F*SW9Q4I}m%e_Rhfw@EADIN)ut{^mAnVf`VbZ+Mh<#v`>o>5JwW zEGfEqYuIs{eX&VWf5I6|YD;(@ccarYcba{)#Se=6?nqQ+(JG+GT%#&^Qk_d_jF{vxIiN#bQKqbbAX4xVH3(jwJr)aYv0$N@A`oWZoN zp&VyAQR5tEA>RW>5MDGwGg6!rn#uRwSOwn_Ump>iZ3}Bu^dgFL?qt8l*Ux1TkFE^1 z!ngijd3P9zS$8w!QIrco7!oSG7 zNcNWKs3bRT{EB?HM3@S3&6Ds)nTxd4%L)usAyGeU|H{cu63Jc>H3v(`-rH{ljpLph zxPzg_sGji1kEuK`I0Y?_CSR2y)Tls?^E34YVIFuK&zN2l>M4R>jz-C?CMDOZfX}7T zmyfd;-D+^_GBd=IuColB;8KH7XT52dXz-XIpT)m;4-?6?!<^pY(hw9Sogi*ih?!J-ac!L37=M7SX};+v0DRC5j8LWg8v$-;`U8Svj{h| zP!?PUHt^5EpyJ6Zi)$$3t1s!19QM@zupzZEe5Ct+0}`L9f)9&(-_PCmmutHxWCZwW{LIli#M6^8bLJPIfLdo!`SIT|0UnD*%c9ABv-fl&#r-o6C{g2p&hP;ym)t%$pYsZu z@wEh==h&5Zsk7sQiO{Gn-hMkFkmh)|^`k?P7x)#VR?1}QNz{T`)k6zbuFhTGynd}u zmKMUL393GwXRkqZU{#+i|55d6&s~b(k$NGW&ki=eB;+}^nEL#~YJygkz+f7D;<)d7 zI#J+_q*N4I7A~J0v#OZ7oPN$55r3X^3Y8$+Scv*AULPBvvUz&-{gJb0Z*9lXrhiVp z;+aa-)F~YpFaGv-5=>mB@%=e&!;YA>koYN|U$dj7()qgmZCC43od1;tQ$M@OqiHWa zPB#40NIj(J(5VZ}DN&FLcFFwt}=FmO$aQI)MhzKj|R>rTX-aXp1 zTDJ<$xhgD%F7rrwDO2Iek}$~f4wdj>AgY$rqT>-Y6-=m<`@j`Wh%4=r*N&yTkj@ zZ&nVvakwXuEuQQd-_5nzeCPIj?qR}z{c5B%IX5wvK^X z*w6K}I^lUNm`e71fw(??8YW^64)R8FzI6qAVrQ(x&C=(~$V~4|Ql^&dmm98`UF4q; zuIKy}lV`1h&;tLs{w{IWLBWe4i-Qe^$4b%(Zk$Ui+Kry> zpZt?k{tom`TpdyYf&UF1p|E@6wIH43V~6VZVS)-KNe!&`{-_Z8S;e~K67tzC_omUB z*zrgC-#m(HMEc-eJjVp2W;D|3cMapjE=`(V!g~<5Urcwkh_#|Lp-%~=fT;L>l2$3V zxl3IN7PfnW*-Qm;zxpcC5|xqIO>C9%@!9>NSC!+`A4*`d>%?V=?1v4JQ-8%tHm1afZuE(!P#q!>|v z*q?rf-Aw9&jSsAw@Kqb{ZnO3CE}uwnMM62mHyTn!%Pu)r#jRQ{t92@oYx>Bf=} z9N_|`*P*dpZ*qiNQA4iK)|;{MX*EU)B{50fFu_O~NJk(M3*@*@2!UkHkwAe-^^v7} zx8e=l9P;M&7enJ(2}T0mNZENv>6_JoRpZ}yz-fYi?WCwdq`^5B8FE}EE@k?TsZig4 z3eSW|%qK8K?q}=snRGw!3SeY#1ABEn_T2Z}-F`&=m9hKlYo`WPu>n=4K)C@b z?}C=6FC`&za!c+!j{JN*ZCu~mU%8mnj&kU$NlWov*~s_f;7cxjsxwd1n|^T=@hRqd zqp{%e(}cQP4{b!|c%~akL0R_U8NQHAV7>FWO(kh>I?8ZhaHyPq6}(DN?L;72R+jV< z(%gi|X84YGnAVnJaf_(L4>s!tI0+2YIB$r$6&A`MENLVy)^P5z*^JCl(uKak z6TxfnA3o8R8s+K8v^FgreUHSla8$dWRA&%NtG!` zF9ZBg$Zi#VF0O#9Y#|jBqEFwtdJ_&ld2n1|4mMwG;WH*(yca4Z2U?5ly_b+&@4|wD zcJ=wz=ZHs*iCz2f=Uo<8Rb1PY5fz}wO?23XPJPiZBvr%7EgKP7Dz_#;q*|`G(&vRa z?%9x-HRkyLPUsu5MA-0ev1-6{qI6PXexZx!!PoS>&_X4&z~bsrO1F(LSMVlme{3NQ z$;BPGfaErvL$dd|^ziZ%4wkRxuh3lmonX_37=NZr{HM=1L$45Z*s|&MojTJyU)?=D zg@XLuKZ`J$Tiq7!1hwi06@BK#Ut0@8@EzOFTF>yg{E5zp9LnEa&0hwG2#*vX=$aG5 z7Tj_;H7G>E1n34mMBasfmB9E0g$U<>r@@uwU4VdzA1KG9LIPM8JT6JdwlOV}QDCqb z6DN}wJU2LjiU|pfw3kn%7~sYze;O*LyS47rOt?(1C6Lm*^XC{H(b8~vWfvG7<$|1o zRh@f-?(=rHfv>d{tSY_?m0M-+J@YHDb!RmVMaz0)p7b|r#Xw}-mv9m(QjQTk+D+X~vbEzovHRPu|qHcMo=sjQ(U4b>DFf%75Wx zD=cSqo|XGg^o#Q#bJ_n)$E}|!?$I;|6cKxvB7$~Ee5;7mXNWRjqxr)5VGe^fHa$UL z!u9i)x+5e88K6YK86SAeYt%OME&OAjcyKV%nvh&V8i9y6VLpV$SDdFwNzB1us^Y;DDZ(gUUK2R6og0~+u^b%1>f>N z^$ouA?xm||abNq~%!wTAr!UD?c;dE&I#c=n5;=d?eMbtDgvFM{mIxc23<;0;XZiQI z7PtT~7O3Qw7_w*#uSXI7LQw~k<>OEx0KEf^L6kui9&a2j9|`5IDm-lQ_ag51+9a!( z>YIi*U7q>x(0QoN^PCIXqC`Hl41#4q7| zr&!l9imC4rl#`Ew$ZWwz4BeOEj1nS>D;fpQjZB8D|12^SRh;Qm@je2A?0p1?C`T3! zOrJq~ge&?wp7^HGW0w+%_mY19T>%_y^w1G5^IcIhE~b}mvrlK2Z{4mAzgV>H_}*Mr zAEw+52lVjJjN!)TrUQ%-M^@A&*0ma5yd_fPq0&5;=M;VZFxbjfCtme0MzwN}uJ&xF1kHOBY2ZI%X92^>PF0 zW+&){Hr4b5kD-cB;X#Th6&uX~l`R7NofG1^k^qHE2y(ubUblREdb3AA|Kv$6Qu;#0ZsZ_sh3$wIeyEBzYc>) z7;|ca3A%!WL8N6hGl;ZwrJ_v6>J3DOdGGENLO4=M@^1K|#6I;|r0bpZH&EfJvyON8LG4kl;-!^Y_EK9a5{RAoBbeqL$opQd zJzH?Dp)VePc=}=E#(Zbnd8#LxXT}3R#7Ee1M2-r2q99WmPsDDyLGAf6I{eTSkNC%v zZ$Bm`-Jt&at~t5dhfr>e3e+jujqtHtpB#EqVj!n0hTL>G=b!ej z&64aBHh6}R9G^H>?OC0Clw>U{Ry>_vp{*~SJUd4X>c81$#%?;JH%kjOcs+i(LNB6O zja1hOZP*`{&izq_kvwg`Gk7td|NO@KhtF8EWx+gKOLTO5^btGAgH=TrEBH+3jWA`U zsYVv*(d>Lj^nn&>P$?+}{`MAW&mQTgxAZ-qGg;&8$PW+nRjn^+U7)#`Uk!zFF}tc| zsuaSk&NBEJu8PzXw@<8C5S@WRs;D6nNe+f8(pqq)*yNG^K*s7UcK4fD zHh2s;pYK#NR6^yrT4Fp$zO3G_etamQeCc+!V)$v89FMZzMaP<($535o?R&;g)}g2p zF=u0(1LhalA(fmA?C7ch`Hj@74uIQ5R6fSfl+W#&`HjUIFxseCP|$~PhXKi3D=6UO z6+q$-6B-F~sPm}X2;c71Q`uApR3Q?_MTB^Bw}@+qjeC&CFrUo5x+yoDeR#mhRZmr) zF)@Dn%T=t4$}Dm^zAJ;hlNdu4@wJQ|RVi8*{+^E*s;k6=3f?f%pU4m!ylOkCM7|R8xI_oihL^e z*fOBB%w10S3y%=?TP3PhXq_D=k%Ph8w$>Yq(2xc*?(J%6=y}Y1X0erT)Cg zH%Eb2B|4T40(JWQOK&$kfxgfoST(D~pnRMi(<&%BgO0(DwhRFx=5(L?=%Y~AA`$-X z*Wj2340b#RvavmaIK6_nxsplR&@2f?CEQqrvVGGr@90|Jv{2W=HR#-^Es7AMQr?rA zPN*d(EuYgh!FDultR_^ySwF$`)oHa$R(?dR!p-Qokn#SKU5tmplsxs_A7vC9KRy}? znON*DPW~*d+Kb@q=`8Z!c1!iOVjwQxnEpjqPhHmQd&VR9C7;OKKZCke`I6NlIFqb_ z`eF<`=Z;8YS&kecRSZV|_%$N~_pQ@lo@FhOte8R~G_52!SQ-sjHjP|li4EwOII4^N zqfTQt((nKI7M?_KW=h%^oIedY_eG`Ar(J3vH~t@U?ug}IjshX~`2h!c+I=5{}Z0}cX!l<;#fs{sjv>^(?CzFow%z*brhDtBnm52CG zE()+W-u_gzpp8;xunrDJ{{_1etizB=8hL>$CVv_?Ql!pPKa6N%I(U#tq)K^2S2lu0 zmGNzzRU%%3g$m}&TlTL&m`hzw#q@}w91$pm=0W{IXR=H!v}G9&=gMpyV-y&3@X$61 z=Tk7{{U-dxy;32?S5n%_geL_Zo0 z@q$QI6nt^;ekke-zv*5BRjzU@TQdqVL+mFli;GK@3`y=pTM+e69FSidkX2%5G>PnJtF3J+SuP;@S0yyd~`QMs1D9G>nGP5~bv-Qhg zrw06Z@$N@=%GPMMWUXG6b^e8GY2Z$4!nffU6l{+yUiW^BS97mF{$;^UaXqu}YXrDqkYry}hn{wcO8w#AS$!mR|;wW2e^eaK*Ow=ltnt0u!{ zp?JkR9M|Fv1F+M@8xm*7-7^hUch82{RFtMp-Ctgbr@nXpMbT}?6|bS~G6aHTfvAp8-tu&A)j0WRN^>=NqQX%(O1ippxp{fD;awi1p+ zZ5rrOID!c0K_BG5`QB&S<=)X2$B{f~-3*x|tY9lpY z10P71JvsxCuK!uA#mPIpQi zf;~qY-YuT;u2vJ$w&#klTF)+BhT7D!ot`i!s$@v^UWdj^_qY0 zV7Bg+#EbK?>+!|@`I|=k{zliMvuUYQWy4X2yb%Y=V2MfR+07Gyy0b6S!wz<5hIXyv z2cr?E{>!ri-89d5A_Ptjrbn=<>n{)3+!&Et19l8FNyB;xH5%B4ZL+UUxc$k#*@VZR z^Hby;E3k2vI%1wqCh*OLd6YO~)|{drDR&f?P;@b`7X;v5_>V}ejY?>zyg{MpD*vQ~ z2|3VU43N{qET#7jzEZwkY5W->E^Pdau<_B2*$OnA*h5bp%Fjn_LtX?f&W# zX4`t=5(C)W2=|1DNOYB6t|$);PIqM@)Kk+Q8`a-?DGP3^ipdxdE5XCg6tF)<0fz~e zYjh&koN!7m3i}0YUIffZncl~E5E&DRqRaq8nJp*G(MT)V;+_pM{gJ3Z#93_a9HM+s|d8IyFWiZc3x1q3WgYoApn9wA^rOf!UmpnU7UFzoRtqQ5OQ?+uf7(7p^s*$ti0MB%fY>HYgWaZOV7} zEW|M4u$#Jm)VwM(%$0Oi1_`e_s&{Jrnm6rJdNpme@X;VXW~OF4$FM(qbxg)}LeRZV zr_6f$X(;(hdaB2qTtDVlelkq|TAzj7`3^sijwP!7Gun0`q40>_Uz@QBbCEI3TuaB4 z7e`y4B*R~r92Q?2UdY_^bB>>F#JQL|ovW0dt{fwKoRrnfucXJG`Il9qUJUmuUH{9J zq^L6t5@|R^ud*)@C>b-ja>y9de39^tTjhnw;_KoniIJ&|@)ui+)jG^oMqA(cR0`|P zcSH+IM>MTw@4P5OZkp=Er(v>I7qD6T0FEKoH_L5}dLYYL=T@ugfzvSGKM>nGZ7&C> ze4c{Rp=!?-xaf~YKjCndYeSXatGrhc2)lTBg>r$CXFW=pm&(Jg0xqsGB~241DIGQt z$&=1=5STjELz~M`IqtJFa*bg$d=#!-*qfhfaHo8kO)}Rym*)iKmSiUs3PHckdBmP) zSE~vXqu;agnabcPxMxLA-X>xLQ#_?rD<%95_;LV4}n(;rykIf9t!$1V3z4BJGRrM^SuGv7{#y z!H^W6A{O?|9niF3t`x#49O$z>3KV}26$s;$OeOE(H{J^r|1pmfBEv#~`kpbV5`T&q zn_)N-Z7Zb&U2w{?I$*-4BO}UY0;7X%d-pk?b+&c{Tz@y@RXz(_Wtxy&)f_w_6o08E| zjQUFixt_aJu2V*2zR15ccJ;X%=cCI9un~Vpx`FVvGH6U)8{`x{zXkbjUgV!C~vX;vpi zqu!ZC?~XC32}w^?D`c)wv@#AD<b}-uWZ>$XB=-6DDl-!lhfC)bP$o=`kM-=y@_9tZ`^UZmF z5%$%^l?N$q0bSXt4X@P}^2{h7Ygm3q~!=_R`7*>WMEhH8S457RNRU@2}opkq#?PJ}(5bZe`3`%ksc-UP0 z#gAM-ALw4HHYNHh|7 zQ)x%06h^lcl+2(p#kBR!-pCeAfdi{SQ5fgDrH+=J`sx2{-*u^*a;$PmTymLTrq;T~ zXQ+f{z4otcCYVx~3bZG|AsK{mJN^{fR?ZpaPM~;gsH9$I>44&bF#MD!PsTk9_$fv$ zh{FM1-@1dP$2I2A(xj%PU3dPwjm8u;llA*b z>!E7sdzl{(wlbVl!BrocW%lxC^?{4iPJN^OCmEsL_v6V(jj=_jbovKvk)f)_J9-4N%Rat6Env&l{Y6TK4xjIw!Wr%+s|GQ|i8W>*66aRZJl~ zMS>v^(U+#_b~rk_XK^w&`U`}1w%&w!+<4gAwU^F5hI_rg+Q1^}bP7kopw(DBr?Ja) zS`eg)Smy0*qK6j|=b z;4)~Ah~MCZt+Ld=GtW`>iN$;x?ZGI96E610y|WXg9O3IsH$t1qm;kvWc&E&LB|Qi~ ze)j}>N#HuXVPWS~;QE8Rxuy7o)dBQ@E zjb~S{2dvqSbJ(sdg@;|utEX)eXZw}xulvusXaz5n>bNL&f9q_G|E04vTm&Qb7`nYO zn>kdNabv(V+i|_evUX33M zaHpo%8m@|NfKHv@aq~GT7M*xwNVMxmRoh1m^+zHE9#w#)m_)8F4_7Fe^?YU)a||a> zWpZn$mRwp53*6wIKC4oCRj$7k^ZjwoF|_Ph$IxvnhD=KH9ORhiDjt$qgTH8DaT~ke zDBKA#9g$hfUdRRHcfRV#=oSld!>=}Pz(~#CecURR?;(Db(4#kk*az;L@~!d*6agU*0A1N7H~EvxsJy1%=s3o}v1MRdt5Wl!hsGb-)i z0Gl5bWygv^WWTeqfLnCL(~InP`nCj z75=t{RTsVVl1ZjgPE$LHc`b&JQB;(%Ti{dwsi#v<6C=9lX*_*k*GAq~IgLd>(_YCQ zkBbTSaTQOkTwxY8#CfDHDx7Q2TYTH69eYMs!SU@c_H_^alq@{#*5epslw#R@I+6DV zH--RpQJ2vOH#SiD!H%}en9)9qUvjH^R!5l-Zw8C)uy|jt`~#}rBfcZO^c)@-lSe%o4CKZ;s86} zMA*(Zm&F6#*5jbK_^LVTS|9_6Ju&e(Y`s zoc-yxu7jsX+3rI55hyVKu=VB1CqA+| zo8wnQ^|fhGvea;a@xXA#PaSw|hN=7YWF-^^ws~vD8}ojwESh1D()-@c#C-eexN`Sv z`8PW=^^|?BFxO6{eRNuBx(1@62tP>K;>l7iW#3TyL09oLv|?6pyVCsg+>priMqypW zO{k3F6?ud`mI3+pWrd1wSb$P#>lPhT(ErEQdw?~ybm78^QUw%Hk*Y`&=^!0ML_~U1 zdgxV}fFX3GD+oyMT|lG-LJb`Rq$?%V1OWjd^eWXm!S9@Npa1^PdNg5Y@12=7tGw^p zGZV#5bq}F8zhty*dxC85s}O%;y9~GOffM$#>9b`hYOZLlXe|y=`_s(v4TFO%5Q@qrZO4YC8*?hCl zkUVNgf?`Au%Cjmjk=V29BBwXU3&p)Og&2+(S9Pz7Hi8+YTK0ZKgHrv435lFqpW{AH zQ%kT+<#Qe^7skX@FXvl`ebCMujXBEPeaNA>KC`XQlGpTuA~`4Sh!XPo7ES(&#)?MI z=RC;P%Xmj3spap8hKkQO^Kdd^9o{e^ukN|AQ^c?*;-TQhJV1AoZ*4NL=|DlzfqqMc$?rANnelQU3Ow4<zh$`hj9bPwtMaARfJ}`W-$tpKIid5YM#wQzZNu zma=y0yRobEbJ>r+G6iugy?QdyD6?-jZISU*M+q?pg3?xRZUo6_-KFEg zrtZ+Yt!Xec#K%~f^2jjZ&(G#3*xIj$YGW~#BUM~A8gehmqViE9x5j=LCGuE!A*C&)&0!EV zsu*prRgH1brZL#i-bkR#4^nCzc&4x7oW$Xx&l*HL`yhDJGwrm#TaJb9ZeO{TI(dg` z$#u?-`+tH->9#XZ*#AT)%#^?R7WUBw|E?`ZRYJmLY_MiR!bW7+%-b_(vB02R>WBBI z8aYo{Cz;-oYVUFFaan3hDHXwVN;o4re#YxnaaC~<_kO^y+k3MG|Gb;1bHvO=tkf0* zXW`OG*CTVXiq~CMM8=eUU$JF$O%KqYFLW>!%*IJw*LFTOxn7NycY+#_uufJp&OnaTj$Da%;WB zl_qM>$a`{=yE8ucHizpKi_yCax9gZZZ8cN4bcmwa+8rbfqte+*Ce%cgC}S;e#HMh^ zSSVHzaVseG#C#~?qREnEVhv;zOW7{c)G4l>QQ1P=_*WXq$r zrz&03vJ2gv6HLY=2?2Q~d%_=;Lk#ft{W0%`14je_ zXK`~X29)y^li!VSMr-Ahb6qUDRCGzHh2RF97QUd+Nej>L7Iur}3JdbK>?3vd`uSd= zDW>cv=i!RaXlNht?2HcNP`iD%?@Ba65~55!+`%D7rIxPLq3Ik_nDm3Kme?`CAb~ge z2P!nbh78Z(kIgA_V>&iPE4lXlyv5IbS?&`)W5a!h!3?sBQUUMB-$D~2_OhLBA>=#C z26WUayl%?$kkWKFhTXBWdd5OD9y+C~&_ZwqVKNEq;+PQ4dNVr4ttPOTn{RB{cWX54 zJdcxOwdkM+SdCN~ugNl95F3pwg(Lf>rtI9~t?Uu31 zQdO>DC?ugTy zo=DcaBV65&hW0NPf2$winjz&}gR6Wau(=fv?J;+*Qo~&bo?2;*S)i zFZ<$DQyiroDL3mfVdP^H9lU;jP!YMg!&{Z`goU!nRqw4dr~0YGqxsD1{3oqe;aa^9 z-OPihceAO|lZDS%)!98y&tk3S+4N!|R>V*)r=C<+F7==NF8#NR6GiqS6egav=qpCX zaY!PsF|%T~6WE!T<_q&J@>DMC7RXNSqIj5!*i+TCK73Fi_0Tt_dEE7~o3bLv-d5z+ zv(%wQDfG_PE6T+brPS|Nr3L&c?n9*PTJd-}#NHv>_u z&>2&1W#MlrSfQ%)STtxiP;mKZJe73F`5|NcPiL^%&0kSAemq;k3(0s= z#;X$XOR0d3;g{pYZ!Ri&;V5bp8`nTE*U7VYQajNI{s|SgCARvp`PCp*9_@+T8{gjK z^FngoE8iaO8p^NKL-Kps3LeeMtEL8VF)4k;b>PSQ;z5IqAmy&1^4DApN?koE7F;yg z2+XT5D$>G|E(mh*jIhy2R`UpAI;usp7$Jwi1RbwoKQwKSj^e zw$CSrUr8?QceU|C=vO9p3gpr!QjRL>&#Ak3z4V`{wHoU?2YbIi>BMcNA6Li;IpW0? zny-jn9krr*jXGu$D^-k(P}yE#Ks-wQ8UKqrfSj#9mNSNV$>UNRK~O(4>rM4fj$T=; z^CvO<-+ctXHwv!4PLRjmCPeR>&3Z1YDG6D7`N=Px_hmZtpXrPJO&5*&rL8hESL&~Hkyx=aeD3uux$SGb zc(^ezXPW7kB@IWOwZu*zT^h>V)rqO)I+c6ohjkvxe5lkm5%rrh@b|D`^oizYew$|R z;};dTpRyd|-xGe;oYkd#q~J@e*qq47P%CnJuwcLUCx+3AVsqbd?_TAR>z z2<*aOV3or=7t?hneV({0vCZG3U9)eHuq?gQk7Ox$pyc9$j$`W0Uq@z(=C#Er8 za{EMQ(o(#H59OwR_c~R+z8)&XJwWgiTpp@q%bX*!tl~-K*{GEeGd)M0{2^Q0Ps@*L zq(3~@%i_V1#^6G4x{IWb);!?{))+mZ7XAr8q7XCbn1iiw)empZ4{*1W4eAif8HJ!?{3JKFJBHb#<--OwcKTKDi9?)$dZ$RaIs_70PdWs*F95ho$tVk}>!s3ajct!8BKW498$Rl8eZ$Gp+TAHxd_2TKiYpZ&8rA9h)! zbgC{T?Y@t@$Tbxe{Za-aDd?~QdETQX&J}$phCHu*#CrH{foxmsCW~aYd^kq{i$3?D zvLN^DVMn;Y{Ya$WDz`Abux7fWT5P1XHVdnZIEy5)+WF~$L~3M%l2qJi1=#kVCp^Q; z1MWyI;XXmSm~;#F2?aNO%Cy560-q6OK~X8C!6C%LH-zOr@iRoSpI7-XS2h@^o;+nv z0rzA9(V=u}yn@(eB5}QhyjV-U9fZZUO2P}tx-!cfA`>z0K3$8yUQctd6E%!=s9>Gl z2-ro&oHXPf%_lVRO4&KbzP`tx7`i;_Ib`}VF!DWY&-%QDl}!B4@<-+S1;4N4uH?4C z3%@cQ2Uxa`9Fs&Nm_YkLGnZUkrLIo)sqviI!4xacTg^t5XDK_uw^uDNaj5RpRz5*+ z!eELZqfKO)bg$4t2o6dXO%zUW&=BwpvC4Myv7;EoXjY&rP|9@AS8lf!8!vW$waF(= zOUbh;oM;(sR%uOAFdb@km(|SsoGdnXILG<5ilx z0mQ~NX2->DJn*S@Z=8N?_29RJAD>SOobLPyE}aLze>W6U$-=GBYjD8ASjn0>{qs$= zrH2-$ZJ|SVP3*B@&N*@T$g0GpRLs4sY4^<5b}_SJr1AlU3u4PJDo8y+FZ#tYZ_#dn zb>X?#M&6$)5QuoS7+e9!3iD@^^E#=l)}?>6ihXfuJh+vHTP;*wR`Lt7jMfZAz*;kO)<-P&TT<6D-31@$o_t4;-rg)>B#qXMNTp1; z$zrMPtK>J7*}pTC8Odr|_uFDp#b_S$7IA1`m7d|CL1E}R2SB3k7j`a+sW`d~+61F3 z@u#JqL@cCrp?kB*kb=sID2fD%n{dmZDn`CBi0o08howD%0fB+fw+~6ZDD-ymW~}y( zVo?wulQIz%=vOJtRFXZ!Ld-U zsm6LEu^I*r-;>bfoq@9E%bFz}#tn?O_ri214j&vFS7|g3+ix6r6&U+69o;4@SzJB4 zD&gnm6nBwMB)Mv<;v-8^Tt>xRb;>?G(l4q3PuQaC!lWpkEcUd=+-SHcmp@>my)3jm za4&*`&R~P3;tC?3cOF_)(}6r`1LBQ%wb%36tQ@~YMY9KgTkRI);Oi%07O)s?A8C(+ zxE9&iQ@(#aa&ez>Ibt!sdhhApQx2Uvp^XE)1(alS<#=5@3)?$|Im$)K-o4(q>OB`k z&*XJ}Ib{l^lI!IopXHUW{TWlCR9m-={i2d^!|}_OZ9=C%v{3{#|Ev1hlS@}U>+45w2v_QG-C6G9%^SN#spa&bXjKtse^%pdX>Fv>^zvGYHShQ< zm{2BNUKD6F^NOqFn>E1OnY?5Af|pLM2TzOS=iECIMWVh?Psa#_1R&aO5!X+@PYto@ zkSQN&UJ|s2s2caYp=r2$P3+Q&@n7M&(G^Xae(%R))0S%G#y(jB(9#AX4a)-v`a>_s0{t`4{Fz9K%VRY&xtpp~|w1v$k| zj2AWs;KOwjo*1n8WS2}$f}h zA0_COMa=pcYSD52Rddr}jyU%mEkJj~x0)_i_DS>brft@jMc(2eX9T693*j8(sa;o^ z<-?;bXXSgQDfOy!J!0r867T2rYzI>m3QUt1?2Q-3_;AcBD?Crod;YTNSsceG^8;2D z4z0E_0m~0}gFljb_OY=3PD%gh{ZF`i;rPX)?Y&*(RGnZF4nUG?tc!hXHUx%`$ z+fwh>LQ4xy#$UQ*dMGnyF@;~8;@YUb4@^(;o8Nc*6^xC~uZC-9dpq$?kCX?EZix+J zcUFMp-_(#y<^gnrCf~d*b(5`u*eSUwsLjAQWgV4>ll*#DqjfgA#P5P?Zqg%~AK2X< z%ai+Et(+QimAx4dq(*WyBv8>*8UJm_ik!760=%qS1bpzRT}ueE|21>-v9Nb>O!Ory z3m?oji^bW?vzL0Yk=*DjMio|@h^RE7iL8mN?r|@Kj5S%pTGdFTO2w_Pv=8070txTq z0mZQbLg=MUhBDx(bQdimPS&z269WS*# zuaWz9Q)cR_0yNRd_5_ z)RBiJ*mxAEkhqdbd`N)$ST2lmPR=DJ<&YUIDW!K4a~BGR7eDEUX->r zDwpg5!CqE?aGl%@{YpO9w>PqRb4Tvzf*)>`aiXqO*IBkdyXx`Uw6x4W-|j(84g9FBZH^p+b*$ZB8LtS#Z(OUOk}kI zdV9uBUB*R5Y@;|_kRRL6o>&WGhbpG$)&A17-ffS1pR^ad7i(!5kdQ@|5x?it8ymOh zv*)v{cds_?$J0ep-~DJob}^-a7{t%wbf$9GihcWcF#_iYl6&>8@_tQI$O-xiHt}J# z?$&eB){Nw~7P9V*jV;uBnE*hU6!Sf2O2ilY`W;*CwvnfMs))v!jdWjAy3?pYZCC9I za*$!(>6s-YRk7!OOfA~=F0^2-d+OqVcsosws8f7OUQwsWtH(RB^7)CM@#@U8mgBn< ziR=?t4XlPvqO_Ws#rr;gD=U)s!)Gl_Z)>zcY>4Srm{)xU?U zmel?n-|fa*!{xhm>JX8z^I6YiYhHa%A6F|4)vHieG=8^D>bzCwl&}s9NguF}-imp5 zHlHLtn#^;mv2Q4grbqcTJH5Hgx?Q_@1N{l9Op6@-_0)fpub=b@<)Okv+Gy0 z>CAh>%jLqR54y&mtiz+H>bYL7vmo-na=V0<96wnfZSTM;w z&XmZW5_wZ{*tNFf>T@vK8Zf00imfnO4V@|TIGaMak1yShtJ6cgT-%PCKEl_`x}F64 z`T?&!uVqh^gRicmOyCZM?n8=C6L&8XT{ka#~lzO92#aQtfoHsE96J8 zOZKP#Otuk{Tvnanb4li*>j@E?UH>|v-mKLeyE?LANV%C%=O5kKJDbpLmD0MbXZkjS zJ2WHSDsRF*{NuQ7f;w9q@q*@O5t;_&$9gj&gO^p=hbdlHa9xq_tvCWqfX+21Y|Y4_ zFC(hFhJ%|vd&5BWjtbyNL#FpNCJB6&`CK&8y~Rf|M>AO^*QjD_11+SE z*GR!TA@O88eIe(ZB_@5Jx$`Tc(@;?5FNv|bE5SXONCuVYR-Fo%7sng7XVotoX{pb1 zyP=W(yujia)U!gREVjeVmoOwfhyIsz+4OQkB%$xyX)2*7OC4y>*vGuah?Z)RU$?y~ zhRNG0?H>)v=2>m9bljv~##M6+%LfW3Zjb%zKiPKY{_~V8G+nx01VJSf_6L4cOi-?P zW3qoK?^Wa;jOoCRzQ}?E65kjtBM&fo|N5OEE_zit`88I+l`fFsOP?6dX+YIKm>h8`E0m! z#(C-BaSQ4=o@(KVP-a@vqj+jDcHEOFV#NUcZ?_c!Rz5E#J7{fu*3A0Eb-xIEhm~#A z>TMb&;1h8dSRa)rlYW$rSg=TOApRD<9;e|verjF~=CSMUA-UTOW%LfG?-o2cKNDQ= z;KPN{3;lusW)WX`N7+(e5?ci%oA8vAf9U9q?a*-YoVZiG7lfkfsidJ65-4G4 z|G7!o=%WKc4b-*wy3^PD2r*2oop+39oVRXEjgsyi?Z7@#Vgl z;@O;VA>N@Kd)Md1QS8}AY0EEhctR|k%tk9lUgq&9U~iM|IT>H8X#25wNv1SI@)l3< zcro@Qjv_W}L?Gw=ty(zhw81xN#eXK&yqWCK;IVH=gi4Hq-ky*~x&(wYrXm+}+1Zw}B*@yluS>KVU!Cw!26-%RX<`3?Yr$qw|NVPV+s%}}Ou z7VL%wXpq=t|3uQMzSWj_fMiyk{jB8*=eO@)FaDW0N{f65@wi>_`wElC-o?kyR3EaK zL%I`wWZ!j(o|OBU##|v(@bc%T*^?(XqXXaBP>7jjso%W<4DD;x+WIe9*J)4b)9z;R z^YsG@8r$)2cmB@6=KJ$WQhFF>9eT9BQ)mR?96V!A{E@cfhn|Zblztpn(Dj{1H5cVO zAtts$nyA69W3;iRKc7{dzOZ&Sa9wnDK>uk?(>Go=9ibfk4z&o*s!6v6!q5}%lCdKc z)67%T4ad5+Vb|YY1!Izo+|Z`ngTUDv>?d8mkPr6;X4@YK^#=^tbhFJo*aSaUCSojH zO5S6g+5HBg<%j0NJFyu`#VDtb9uEZF{+y|wezoc>Gmtf^{>ZAxQ+;Y`!nk2>Cu(|g zB3do%p*&Qy!7IG8XcA+ZJm@~kx7*zywP(+KrTxO1ikCH`V3VQSWa|FF0?#n!zyn!% z(AY~k>4mQmxbHhYpWkTya$_&v&Z%9GSjov@LllarhLN}g@3J*2I5{{CdF_=af%gdO zQ;~QKwtN!P-QBkF0)qtd5yqGRet9FfR@pNaV=DW$6qYqSy2sWSdr$IpqwH;wWd==8 zJI|d|J5Mc)RU^knT8{(*69=2qN!reD=q+w2v9}aa+X=Aqq}y8*sj=!$sZw{=8&2IF z$a^ciqT*TL?RVI(u(8@d$ku4C=%n(m^hgv8gyoAYr2oEw+RbkeYLt~^fZ#1Sd@~r7 zI4Y^eOh;C|o&1son@-AJQt?=_rXStOZ_sLL_QZH%;zSlo7Sf;m0DyMm?F+$K1`(@k zm>`kaH5DiB4VK^o&q|R-t@T#VAqlhIsaSBqY%UR~iN<1#b#CwIOi*)19m>OW+`)3l zkFYQ1i^5|&s*;+oQe%NKE+ag8G=g@8m(s5^=QeO`yk*iGmT>I*2Aa52v{Kv8u@SdX zmR|!J-tXX8<3Ssp3e>=y&>sgHD&wIAnpR(z0sE+{eExpHVZdv2GI;aM+rl95tV`9; z^ON0R=FPgI(Utd4(YcOg5)WAcD7SKLlQ6Qe5+2(g=u~g9S9Q0Zr`k&sDf0k(8fAcP zOD(O5ISqP*hV|n9axLUf`rD2KpuXdW5?4@W_npc->^!{sCBi%C8WuS$9s{^fPWPB- z<55A;f{J^hd)1-HShrW-lsSfCqbBknfqkk~cBjGw9ZYPref&LYFs;;3|6-~-CTSD3 zHGm*gawlAM_oH%sK4bsl>Ps()&C zMDrib;P3Z+Um6yUR&z?b$0vR_Y_6w&x)Wie=E3f>g4vF|*U$*Yj^Sb0xSeB}$CvA0 z?HEO@K44~1MbVhz#pp};MPgv2LN`-F@9#X@*pzqdN!@;UJ`quZ{`p_z#t|@HJM6oQ zogX~iyepc#J;2POg#lewaq5wvn)R1j>>JL$1e#2gaAno|a1`hD33Z1r1PXCbu*pRZe+_^!ixZ8PzUg_^! z41(z@Q6fCxRKiOPbqfyVVr3pN{!>=2JyRh@EeKAU`#%?B5-3uIF$u%=;UDl zx9X9I_*#PNarr9W!nvL5W0FOih@8LxRZklBN(A5Pe_1-8-V$=Z?RY2Jf$ZqE#OZQ& zsg$4oiCK+)`u9&>BWuvEf*{z}UM2Ug2pVAKD(=R#>RWL&9gE_a?lS0tP?Yy%by09- z$_$%e(`WQT_1Vw2%^@`*urDX_FmTCh5p=r3(eNf}lV`#JgZ+-#Ru#1wf61r`^Xi#; z5Bq)ZF)&sNEO`$wbkOjP)i4{oeg~Z^@fSHZE|a6Z%;I2}1afYtwkaiy@y^l=cC@ny z-Oe?CX*T__Zna^*i%?tY=t-*o+(x?5j(efes>QA^Uqf5P?=D{-iC)rY?(DCA1;L)o zt}!_o^ykVuGB`18ytO3!>$c(;ag0?%GqXBQ;bn(@2M2!ia{%o;yGQo@n;V|`V< zAiwhmv<2+Y;=nWOaQ)}w5J#BkXd{IzG&JnaB-&qf%&3ZQZ9T%q$-RJH$o|1qjs~f@ zl6l}tA3)sta{ZZSC>hO1k>zw_ihf&FT;Nr38j|oEk^$k{dZ;z$JeVbKlhX;@1CG+1 z6A1zrh^HWys(7SsSC2|Ye^WWP17NfEUvUQ9Go|h7w)3nU7wK_->F>nbQMZ8?i=`5x z4LDOEs3=gqy`zr-ZA$|xdxAD?*8e%YC=|6UbnroBVNIr7QaD{5Lp;KOp+cB)+h5LZ zxRlNVzK>l4rjChLOWlqvY-s#hvarSqjO!(cg1IXLxR))?zhOz}_@}WG$}ZI_G`#oc zp!8;37<-4dzxeA0kAC*Qye%}aN26efv64-Wlnyo-~etzP0)b|gke;~U^H+N zGjKNNKPWx7%r{>$e_Fd;M6=P$A28<4I8wmm$(Tv()Fx5jd9L&3w*Pf62&V6B(4IOx z{ayqO!TQmkjC#QM=)J|cO<2+Wwi(h(1@+78U&{EM|u0xI<{fo!2;UunDS0 z&jbFmcm6MmuAKeM+WoI#;~!*Tf+_5e)_<)(Do}zAqhG^0Nnj_1)`l zE33GW(T7#r;eFaQWb2DS$C`%Y9Ceb9V_$)G-lm<5*! z*&3{yNn+xrbiA>D*}UO z!l=2+KXjnN@CVnN-@Rm3s-I5jG6~Y4T|%=F{QP#V$K=r$Ei>?4u(x@O#8)rTY({d_ zlYy8BqKFF6`qIdYY%toDPPoxNKbo#Rjas)7Jcvn3{L;X3ljDBs23x(LZQibaZ)5C$ zm8u&%|4bv}8reorU%tCZ2P>1jjKF)4c+jTR%3SzCWok=kuoBjHKPf%l^ozGEtC1AUs?`pQn- za30JszV9OZCox@qpzKUzXD0Fr7M?GAvnw`M)lc&DT~&=;gei7Sf2+%B%&q=Zb)mpG zL+ao8sn&G=t-uV=OgXL5v+{NO)bT=>{>fpZkwe3zRNr>hC8g1}5K=VgW<5ztZ`vw( z`~_$|mFR0w#T=M0&YDnxW~My|Eof#Szb~Jz==Ck7`%v}xds&q9)ZiuIdb;^;jjhZV z8`qmzPYtNVbB;N~4-d0_<@}p+M}1DGB6oOSQMmR=Z^N0xJ+h1r_Nb4}eGb`MGFQ+U zukTR5Et@bNxkCOLxhC<;%{cke`CRMz=9yXknYa6HupW)}d9>kT^2}yxQlE$;MV;~J zJ~@809;>i9%nuV4WgN#t@@pPJRazxo*LC36r-Zs)CW5W%FXLH1v|hSxk1~!Eb1WWb z+u6ZS?HhhEWf9hVVO8^0_XRhmFfj?H3-y(V+o_}`iCw4os~75(S;MNXy@3qW(8B9C zB1KH73CBx9@!YySZf%JZ)W6}lT6Tqwe-rsi%YoF*9kTkY)g*Mx@?I6q>L#*}f+LW@ zNav=JH66bnWYZvGY!-U4h@^qX{!0sX6M6FbozQc4NY6oHGkMv3S^e_27ysJ&uel_@ z=Zl4$4Ux?}nG)~E%7IvlklXn|lHQPxv3?+kXs;Ms&>U)oz5+L(E)B$PTgw|MTz!Wf zk5O*#jG)aoy)-M1#g2pTSxtH44v37PQRrB3#2t4?*02zH_!z4O>{ck5&$K&(QDPVE z{V8x_gG=@rG~aXrD|r=L^$zUh3vTPeAv})#fsEVW^z2f(C6@2TYMmwK9 zy?z(uuN+v?dL;-YyrtPGu%V_-?USw;zg)UA{zO&r8n}yQQ}ZhZL&7mVBf_z~n{|z3 zSH>(&C@o9P|0h>yvy!n%*l$S0Ot8XMQO(-}Sk23+n+d7Ga##VVS3fB}NRr-z8F*{0 z8_B_tsJ)RVZM4(9a2v>q%;Y-qQEg=XKSEyC`}{h2J$he2Ve{OshFJf#t4ldwAl5L* zq)b3P(0FM(=<~>35f~UFMx&Z0`=ytNvz#yKadXmVCgX=-PQS4d18EIG2eI0pHJ#JU z^gq1=e~i6otB;pglX#{l4_hos{y1;y6!2%z-$*RNa5S}@m6UD8V#zZ#WVMc-_s(ZNvBl#i z>u!ZlgU6Zklb^sMq=VzeVP0e1i?jOu69oh=k4 z4>RV*ErS(t>VpuD#b^I`gH>*~f)&n+*YfDqP`fhdAN)F%<1vk)E7)^-B@ zP!#^iqzz>Jtv@OoYJ=`)V|A-}iTb<+{z{(A@W8qQF(I$yaeV(2yINvivU9Ikhpk1t zO!>8Hq_|RqqG6+S6H4@vIB8o2%JPB`?j@cE<+Bq%G?uzIxrmuHqm}%VwJn{;aCUem z&nDaio%{~~c??P;>#5X^0%k0(q1t#Wc{Uk@iRp;O9Jo@6MXlpr3y7TiFTK{+cg3bdko3;n`e;xma_`3M| zUpqETl;I5q3Y=oB3`^boy*1xcmfPK};Oc%fHJkN!F`dF}KK(ziG$36^I$}^V!8-BR zYAKHBg=cb~y*2sa$-!SgkS~;|Yk5!?+kvswtp-2B-DEw7y09AJ-g!=vWrt331*BC1 z!Pp<7Epy>dO#x-FVE{G)Oao%(pIXO5Qi7-*m_ze5l4o;ZaA4+XKZhjFed)(B5v=Gdd8GlsiXg=|zR?kmk zu}&D*(Kj&aQjnT{fVYMfnF_kKJW2d>Ms=Vdu|xNQm{o+DOE3Lo#{Z;|4+N4wZU$sdNjBuH97Sz9& zEEnDYwbki+YWf}Ny{PfNEe9$lA^J_+3%mX9`#!288(Iv+1mY+=T?{4uDC31~0ZsjK z$3ANqAG~E*A&2v9+fEr!Q=mK)hv}%C14G2dAHfGE#X-kpu}uvw0!nmBU*1o;!FIF7 z92<@4(=$Pil}of?u!H!*>c&>8H;m#|9Y-7d-=JuM`X5~Kw8SgnY^=gvJr`nA$#V_F z7M%2w(UqfE@4V2(>SEiTUW4;|TdqKXBO0(bP{1Lpz(6Au=26@4=T{!i7EKyu41K$0 z|3hoB7*RPegyd}7I$zrBm_b2PtaRsU0O->=5grO(90DgVR?1nwfW4b3tV@XUhnl3P zL%%;3G*4eLsUa+xV>5y3qF?{sg`B6IB?xY*+_eQslrnQDhi)+s#kDp6ckZF~BsYsV zJ6z#2^iL*Ag~-W;v8lXt;cKnDnP@cQ+aL(P2txqG^F>q%-AwyRlgIRbp$>38m!Bd= z`Zdlz%);$1J^1S`F#2a|(h{L?LQL|8^AeAL;IuJr#-VOlpfrAo0 z9#j5}JkQ?ui2Q+n8;0IhKdYH?8XOwH zZfTVLmRt8uId%STRwQrnALnl`2bwZXmj>4h5Ic?6=ojsm?Ok@fUm^Zxc3FHFh}x`X zEzoJ`p_m9r>O2d_S8(oxYYsp)b)X5P!m@lIoAp6$7+fLWF7$)67m9+^WLv|EKz(20 z5hj_)tqr(QqStl)D|Ew#U2&ID9TBwJWB55xB`0Tear3>M9;HR`Mc}?;2skc3;1cIP zE>v#U;y_el!DD}{w#Uy`3{C)pT`Ij21d_@u@@K<)oOi+_Wr0bO0*mieBc=_uELA!@ z%K?qi2Pp}cS5t!`9%J2~c;Mj1xxZI^|Ht2vy$&+D@Uf?1%`ngY`R{0*-YLJ;F*3Sb zDCgskf()W5yPXG;7oIOJ-^N9kRb>Gih@=z13i{L%FW&$gZV@0a2Jxmv9L^)n^c5UW z+&;A|xddF3PSxPWzXjXZug^5zb(J&_UqLNsP0$39Js`4kVlX`TZ+W*OSl-Pgmx<0n z^i~V~@>|_47_-79rJnyQDZPSx`GCX0L{fsY$?puqaOnedwe9aZ0&} zqYM{6pw~xz`UkIW?%*nKbtmVQH}rz`me#ytNj2oK70)#ge(-*;RUG&~PG2V`3}0LI zs1HaC45)3$Q6PW~Od?kqub7u8WhDp_g`)tBN8#edd22w1^6R+T$0&t_7poq0Ext*3@Ze|D<=Ojy;J ze%i5<;b*~FPRJ&Tb@{aVzLg*cnt*Br|Mc_^{B~;jaWR`zO}PbHzCwn3u}$n-G||Jl zTz-aghN|T6USPo9&6w8mTq{LXMbk+$3E_*9(AHB~GvpBOcfwXqS(WjtHe^(4}vE4OoI5NIBn-oCkbONqvm! zwUui1|AMbgay&cG`09J6|4UP{*rBkgG|-rv33vwBzSatqirP=wJ*DhbHzgPL zzu;g8^4~a-8M!bnjrpHv*HF#qkGayN#btHlOI4lw!KIBW^4I_qjRPKV+44f++^XWsw7rLVn{D~x%$eb_rqn2?wa1b^UG?*jSxFh1E;YtY2W(lzYEN_cVhop zVD7PBIkcuj(C=7(@XKdQ3qcI&6bFLL(!>Ye3KuUPFozdKb-V}qUtA>9f-@DE(8T;+ znIj5pzqHG{9q6W6sF+4E_%hB-<-jmLE9Sq57B&osVKZ{<+tqN z3h*$sR!1lUcvread8u%4d_@ID#gOZtC7lc z0?!FY@vl#+gIIlWG*}ioR&&`{*~;%v-fZiCK~`29<1e?;GyC~?u_p;UZ~tL}XgaKL z?r7OM5#-JGyZYI{Q!Q%#EQ4koY^w5a9mf5~P89uNgeh3Jo%u~!>@~2mZ0I__9b~uG zA6LzBWi$eY`~&I^Ve9|Qt5Y|oANkIcBmqHQ#+f?OiG93Y+>T{L8HT$4fcob?FzNzO z#mpbzgf~z@LvUdWD5S7;Uo90RN+lLGD+|O{6y&~weAUwh>Ff%ml_zm@qV#7?Ld=# zXJ6tyr(C*Sf1Lv4IfZRp)us2c1>bpqvoe)>5Uu;O8VN|+JcVUxIO93A$P>SW;K19;5|P3?d~YR zh(V>H9bRMgkugMwB=ul-OXaEQn9doWeOo-CE9AQV60LzDwWK{RkhbIm)PT_Xqh!9M zx72E%YqgQ!A2>pN4o7Mb%5NH=9BJY>_h!(+<-Rq}_oxYj#CJv)K~{Ssg#S0!nc(zV z46yo>=TioRC`+}EPQUN1is&Tk{EI|>`<+qDB+9etVg=sP5}024E*{m^2Czc^fc}MZ zXhDM2(5)T7(GpNd$7LI%c)~F`X=kUlZ4@h`&<{{|0-yFl|HrWnoV7k@c3P8FA(URb zja3tzMx~$aqKd(T)9G66B0*Yc6tZ#scU&Eh8AB+F^#kGezr^GlGCtJoJd@)JVDU=S zUVxLr6~;y3ku^B#;f_6X0*|C^J>DhF#uHcaXxDvTt4>_jZA|JrJ5v&r{4n9_aQ*;XkxQ0W!s?<9oWA`QNkaxMlF{`ZDlY6OaZ< zcce|y8=;^O9i{vRD)!XsJcvo=b?Z@!JWUNGy9`3zKSFvAd5n^YbooJ)1t!psAp9Hj z+vP6p9umS1e##8J8sVg(D8YS9En)*$o=tiQv>G)5;xLW19R#lfQ3CQ!GU*9;0?<#Z z7WQXauCNh+hWv_FaaZ`eIEG?qb`%{*Is&N=9JvQYOG~9d+~1B1=`^{NDeyOJ>IBXI zt+z=s3+N_3V!RB@K>4K=JQBh49IvvHCs?bdlDwGnbVz&vBs9nO`)yC?b-T_bbkxHH zB-zVPru3-S-?k#G-M;NKF7;@osqR+czq4Z`HxA_&Bc=FS^%CU{ zy(6PvuBr8YiTLAaeEq&ImT^U&y71(@a`;c&F5TKCH;zAA`ctt(`=iKjUob63+PieO=7a6ha%F7ayI zB>+@JxSk(ZZIH$0y9R*0QCeHAe0D6&oi~?ytvmhPvG3dRYsgb-cqS>%p%nfDI|kh@ zeL|GaY$k!JEWQm&96*x+9C*@U4Ac9cL26&b>c+s4zpr;sA}_!}Ed;+bb&uL|oeD?I z@f+%mg2?Fjzkw@JNV>H<81!d{#F|QYH6TjIMg|7f4iF4AeaU>W(lJRcFv+@KH-PD1 z(S7~~ha~{0w~RUI1E4qg(@Np7_x>Oq_r$a?;T05q<9tRCKGua(@_p-5e<*!U8m?jq z&c`3Q4`}_{i@>oaM*9*_&ZuC;Hzp90f``NYxKhu1@`l#mgXsP<7W!NO{CVn?$iS&I zh5(nq&v6L?!DI8L8Zj_{R93VC5UG9T78Z`&)kBMP+x(lJzCK;Lot+B^J-W8T^Q}%* z{m(%TLdRkrk|NhAF>Fp3*?{-}@{L#&;vBDvVk_*<(dnnlU-dxM$rXo$yl6li;z@b% z1bg@Pj+8;)#%}PtpLhSqV`Mu|wkA5>^8a~e@S$pbcH5+8%7~2+U{4TvV0HgO&wCEr zmjIONZO=BfX3$OadT#}IpDwnktMO~SjWvWtdr3$azP@GS;xa^^ai)D<7}ArJ_@^*5 zzN}W(4;BG;#M@Pg=V}~$n!-k^wIbi@2P1g=S0?BI?|66ZCjg&U;xDu!udAj5wAo7& zg8M;mnC z93YAby>$5pCB@-h!6n64z5o^Dqy_mWwJSnzQunS^QUE^IY?LnFq!sy5L-Y82KFRBY z9H--`)1zv=+gbqRoTZW|1IqxAXG7@?lnE{H9=a7d)hSMg#S0w0Dw-SLVurb z=qRv(_qgnZJ0i$nS=_!7z#%IL_g70UBQFxX>=j)2cN15U!5cZc5Im1-VAusTSalh+ zsqbGj!(Dj}p=!L2vc9N^Z-c(*LClX=##gFw<)KGVb@cA(=>LslzwYel3P#XBHOWRk z5v`;ce`QTNDg(`PC)z)fnQvd*aw~Cu1=pMLo~SjOb3da=KV|snxGW@vN&k~U@&5v$ zx-QlhBv;RpYp+hpscmxY*0nydQ1eAFGB^pu=E&I$fWQ-rx`PWmhFtAX{|HcR40Hsa zHQ=YJ{;WojmvUYO0HxZs3REiRw6oIzVZbN7v1rl`surMl9{V#CN5RO_HnOOvZrAJ^U z1mwRw-_Y;C;guDy{y*M~OJf2Wqx-SCD#;Y_9sN-<*NwHob{$VYHT<`H^(&+cpB zR-m;1m+k?u5m~kFh1W47(YUzvYrQcXS0G8I#(jf5K8Zdx8ZYPiUPyH6;I6_p! zKXdt2aC7q`( zv2C}-aL(v9asfNnf!pmOu(xcz!FoXI}|vd zw9HZREO9(u7uj(qM-71BVw}WJb?^KE9<7`!PNhTYJe?-ypzsd#RDLcv+GzsG*qese z(?9d%Pd+_Od~H(nyU;mLd#d!L<;evUns@Y|OZ;ux`pl3~vqF?3aS}J?FnzJM|yg;V#=kzT% z_9Afj3R@~bKLH)F29CzXCkS|{ZOug*5N{ha2!O{~`m{>%ni2`G4Ygmh&tlT$1oTb| zo^PVkDu7B35W?@(rG}dcgO^0+-t&@)<3cAgNS4SL=wDU>g=1T5U{gNg|82_0jsEv( zOf+35n1g>F-T@QCMftnhE}$ie+21->;K*VHN?fQQeo_H<-1`(+_Wuy{@CX z`~G}>-~adV|2?k9eV@~HT@nL$%4RV$T;d@SM|*#ZIK_#v6u z+|ojkCnUWCjMfK2$^~X~+xgeMO^I{bFCF+A3JuInvuUSH>@TcaFMCz>oIc%`cdgc0 zShL{vddJom&nGxoYK(j%=*>-#_B_-N*D#$8*G`Y7`9Y5uyw%C8w0hYHU^%c-LY=L=;kc z&1u?$@+l;V~qLWBvN(M*)DRB^*UU9h??7$e$R0NFtp@&39tTT6_8d|Ku zWUaUyxExXwz~-K>a3XH_w zG|QMeRF*Hldnrq{<|LwLocfoZVV4(Sq$djSp6o({4L0S?yoFQcx$(Ay_`xdEsfuE- z1hae#m|(-32Gib@wYUngFKB0sK`VhbM6wv%(cIM*Km_n}0svCUd%Ue0nVmym4;_-G z8X!1D7b9EeGUIZQSo?nUAKPDkn%7KKtoVKq65oAeYK@fgD%|Yg?jm;k9ihaA8k{>2 z3g){5`I8K--H&$+%W7nJxKEI9tleM7SBoq{BTa9Y-28QINxa^dz@DdJX5*Th43_4; z4E<|4 zE_cKHUuNFK&+k@5DEa=@FftJhgKzyp-E1!7uA%e9ND{Qs6wU=4bbN3!#vwE3fB5EW z-;K$C{ZPd0mH+yoh)8UyxLw}E{O~5c0_kOB;F);Cz%dW?zJIQP5w7ZzFovF@`=AwMjUaw#7 z+MeaHP!JJ!-1Suf60G2wB91{2srF)*0ry=%S%eR8Pua)~!OXc0%3s#_Abk~dH<*e9 ztw=(sy6Qus*tAnA`!wRxDEr8%nEe)hK4{IXT6J(nzQMbvHw16cq#L}{gW)V(dP%8=i}UDm02)@}8Be=s)8z!>4bDg< zU+-_wheNMNrQlWgoT4wOG>k2c(s#iAg z#G_DXcH&z9umbuBDUY?X_-`3>GVchW+QLhD>Z;6Rz$U%?;Y=aXM>!5} zcf6PjsU^uHfNt_{BC}u(>+LsoK#IBiF52Ga!pAitM7_bZm{}||y&~uEqCgtmlaw;Z_9P_=(31YJ-BmNyln+fNrt%|*XCmF9VUsna{fYK7VSe}$6m^`!eOMLjXnL`M=0OHxG6e4!1*I|%8wkLKQa-S9_o_^xd z`hP5r?_$}TUF{s>rZA>!2s-4!qd z9QhIZMFHE=Gb`(Kcez?e?%+f*XeV8vQ=rF0WHCO+5_{^XHT@|ukI1%EnaSV z=xvBeQSjB8GXu~C@zK-4VPk$vdzxW8_h7h#v3EH4+bwFd6XTt-hl^QR0ihD;@d)OK z-@BD527e5rE z{XTb}VRfvyraFv)w=^GQL|COEc5m?tdz0D zv2*vipfg14A=2zr#TI~2;yoZy!C1g5ogPvR@5|<&@AxD1qoMdR{5=RI!%#bwcM5@h zLBk!Gqn#DF4#E-G*HIbH`>qjMPirb>gUVcR$+r7D6ThVcgOo}C&UI#cEWAs$L^Y&r zzTqRnKiH49M6}H=)VU}8!HS{6Bos!h-`tG>?{j8`)Ic#|oTYqC!wM1AoMwm{a8Y)w z6)u1ky@v!4xeLk!#7m06ttaEQ5J^pD{urodh@k^F%Tgf;yEv)Pz%xYy-!>nSIrncM zvbKRVU9`$LBSna$D?dRgJJJCa-{hwe`~1=}5hoIIC{>c)?R)i7gf17Uj&E(PuY`}~ z=t0L7XQD&-x7m{4OKZvqg`nHN3PA_+*I{58npoj_aJv^ZQUYO%WUA_d{JpgjU^8F*zFaT|XQ#7=t*T^KG@ z+_M4KAT+o@j|9SdSq)*!2Imc~4iv?ZgYU?M_MPo;|9bf&$H;O4cR*}uC#Q2XFACzu zd6JpL&OnbIT4|n;!0++YfulW7PLF*+ryXmt$l2lu{-s@p~$91EdQ|s=6-T&MV z?d!YrfB%XJcg-WK5Af2(7)Fg&3f zDaD<8b$JUed6Aufrxc6+OC2-$pVcu4HUxFd>K}EC(ZiP-T8Ca`Su;X{b$JZUWrPrdf1QIPi-SEsx z{mE6w3xb*JKZ%U|?CzU;BVLFgX8B%Y-9WrYS*)kB^%3^NIFj;7JG`%h^AkaKTHp5$ z(M*=MgJ+025N=xJLlKg-!jn9%LthhgWdzP`^>4egoD@NYetG$B2o@vs!uR#~VfRA= zxlVhxw6Ya`1o!>6UEp5QJ*8DHZUSEM#n{2Yyzj37qyypxv;a%&6Niq~Bxm!e9%X5p zDV)&D&K@b#nE+LLLK~d^?}S*5U2kKAI0RmPDNO!~=}d$A>~`qiRt&PpaNq^u>zA-PMyX{GVc>xg!0o-pT86Gu*WUz(PAz>V59PSsg@#)k;-{8%1K%R#!KPXU0@$ z)n}lo;u(+W7o;ml@gw5AI0_>1zLLfXm6_t(t^c6ZbuB!?p291Q{XE$u}sC`1`@~BZW zry&yl7nVKrzhhbD8NR#FA>n(}fu@H|*u;V67umhNm3Z!}pY#Y#Mf;(tD1cqu|2WcA zl&AAnW@C99m?CKXozfjJ2I3F>2$_LdLR>+716<#YApq%Sfn);V7HO0*nqj0KL{xW& z6+QHE)a{9*TmvP5QH06bXn{$bm!eByvE}7uG99cmwy{ z+61gYPr{Br<)=U^^FcORL=4yUhK@Zh15X{01Aiy8j9-uaCSHiP;K*|&aL}ZFreTlx zI9z@=ZNH&o+1y)tgCvfC8i$+(Z%QBw4%_EJq0b#y_C2ClB$(~0wfQ4l#2+M=4j}WJlczG1 z!Bsph0Qpsc6dWiu%jyj2%%Q&DlYCDAnumIbhwZ~(^$OI3{y*jPix`26^DNJM?^DStxT zC7nxt>m9a&MhUQ!~-(n`m_8zvZmV`+yQfPe!O2i%N<0|czc zNoq%2mb;bZv0Lepi1&lrL0`HR!5xua%|pNoLKFAjTr6GQ!!GuR$H``#^V%JD5gO4N z%S!I=_{lp1;c8qdF7Mo9$8gMW3)6bkm1)dvJpTIMxQ1K+xSMH#fRnjJI9T_JXbR_L zQBI#&FM)+!C6nl+fr&1LL9#E;Oehqo)my}&5K~|apmoPRh8BsE?=F|HN2LBWjsNm@ zkD@6a?~Si5uzUy}-34ev2shV6+HWJjB;h+rer9)e3y6dW#wy!BU=)cDU(H4;M|@ty_6`CC^X$s zAAn7NODhiK+7}^a#HoYW?X3VS%;Ris>Tao6)M!NA_%P0BWiIm09h-ftv@+ldul5*D&ub3YJ`TNi{E1Vo29h&EVNdrmoYxeL^i#nS(w^V;`@PViD2B z$Gm;nL`~p0Nj&K0-}8)2PzdDC=ljYLTL?T$1w1*HWd=$z7m==@F`G}yp@A`Em_Q4+(v zrErl$;VVn9wvuT?+k+4~Uu6Wk;DI7*{zkq4qdc;d9B<0pO= zd2ih;wHO$zs`xmwRZ8gNI#089PwFY%iz>F`Q!KTJIGFvKh~x#eD!%7ZGM=&aZHuKh z{=C@E#yhOoKaMA6@3THTzhwC_%UAK@&`0T;oU5zVM4Ru%3;u9{^gcWH4%CU|4j5JD zi%en~4Po_3Wh=qe_K-#7A6~%+t71hGOjs|$?Ocx)%g2h6o3WmTx3FwLhy?--wb2_; zn@Ny1FuS-nrVeO{h5qq}u*QVn8rHoOAuZ@2 zCLLh(=6`m>Is(g3Q8Cv*J*QdLgK*E)#vJw4Lf^A8}$6 z9cwMt?fZVNH+=E%ekg=UFe0at0jji%9WMnu;@!)Q>>D%uEjb~glO6eqdPq8GaNgtJ zudSL4{Tia*oONk<2b8+`aeZYYUpOR zSl`6YyN8S}77>vgH-Nltg~Z~CvxrC2%a8d}=85=ScULqh=Z@$Wc*JsTB6pxdnRQ10 z>H?bfBq>LDHvxGnio-0E3QxR8xDuGIl6Zkf*cL0rNm-=(W3>?lAE$%P*i8Eo>Gc;0 zASD2TE||08v658esUNdJ%N|a+#sYZby~1P=bCpJ-lPwQEhTz{n*YhHSR(0}zy*Q%PM|~*7 ziYGY?QJiig6}tnU=jm)t?BO|iC*7a|*R1U@5C!G|0U9NRUHQ!HTp|9d1iDz>iZzlj zMPk2S(DJh43x(~?pvf#7hKmyNC zLOA@+hET>vghzv=VV9ukl3a4R8x|*7B>liC$vw8VhD>N}4XJZTn97pN(mZ<$iqPwL zmY&7#Ntui`!_aQ!iy=nlUoYC{20{`Mk-FqdSSPbQc>b^M=B|L@M629(rFc-W;ZUG% zgYb!uw~D_w-Tcz6mERd^vfI@Vr~Y4!!@T2BI;rIXYj|SvE1;uWr6yUi&(JhvKp_8s zQ&M}$3yL?Pa&4thgi>KXV(kMixdriRXs-ik@)8QLi$xN^1N0MGO!{FWgL9JxepAwZ z3oeM#?~&N!Rs^Qx0F*@u-4Ux)vA)*}MG06}Bao5c2)ly@9Stp7fm2qJGsj)8BI;xM z5)ZPl2Z5Wqb|;Nk=fY}^5%t(<%Zc}RTi6i#f}z!8HjkrxxGr}^mTm`M?G$-Xm9#Of z^}&@1E9eX;5l%is8qxjib|4}|avl&TAc*1jLHMzj%Zfz+> z-;6$zToF;xqGk^mBlGGg`k=707WZ=V5CSP%|FtDO!`S9t%2nSaLpb{Adnx%M8Ts=M z1OCyFeT;AJ=uG;}<8OZtVr{ua-t&p^MeF4Q$kTvWO7J}7WwCp)yZJ~mfgK#rC7Jn1 z%td%GXe}0OzBbG^;HN(zT`irLM#5y5SJgT$BGUdJi=@B4|DJTadvXIm`i`(brS28z zW1Gd|n>?RbdKaIfWB;GKW_Km%8#+6GzExZN{bOi$*%jBr9~X8bz@9rGiY0BJxm@>m zST&LLnVf`GFm#Rs#=}=zaMv9M;YW5o>*Q~Fw$rxYxs~*_#3vB-wWRD!R2BKdm3K)| zxtEsu9d>1Jc@BIsNX);rn``7-Yxx5;-6FEi z%k}DI-DZum=mi^!r)rJKpXxk^ghO*4q;NY$?^YK$-9I4|gq3~3$pCV8CD%MIMwQd^ z5`UHhcb{5zG{`rZx$V&oR@lWZb_DN+50S$j>Xn@)yspuTUEuLldWR9otm%RD4?#{y z=Wg>gvm%@kwQwO2TJeUe1_ul2a^itTc;=tphHuPA#Jy)`2j1YHNM&nUq_#0$>AsqS z6M8z|9(Rn+s05c)$RS)5q3kWrwvsr~JKq1jXiaccR>aTe^wpozHJKlNjL8Q3{qcvENKrC=;&9^?<$uNLKPRau(7#SfxH2$uEDD3cFI#|sln)T8K@etaxNkUD)*g% z-1&1r1ChExQfk%Ryy!fU&zmuMBEkC8cY^V5zc>}Kw%CUKie!EDxx%0^4GfFanDm>O zj(@yT_nE^piRs8j%~5M?BR(6TlU@Luq*c@3!*JRvU5d_#4zN@{?i~?zw_W{DyKaVV zcB1xON0f8NhI1ZDH!0lbuNR7ViGa^@N*qKFuYd5$em?&pet~9id;jiCO}qK_!ugds z>)X4RZ#NY37%!3M;!l$oad^<{I?ENTL+sxNMGrvOKR^>XOwBCxeOZ<|LNbo_o-^ z5yuM=PN8O3ZHCdv9a;8~e+gpO)$o3+%z7ztU7?u(L;EHHnj{LZoWEu=SZIngZOlCq zC7|R1!-3uvBX>geBLum$UVneyfxPyomQY4X<;_1I#b3X-`zZz61+DPCF}A~~sa4Hc_RpG{YCih4-8~2wQ^%=5!OvynP!9r&(WpK2Zk1ft>Ea=ulZwH%d=0uFHX&OMs&LOELZzGxfwH!GiK6}PwT;u66U5b5!pXlCRo<43oR3bQNB1E^p z+rFyj?b6a~=kPUh$v`V(tI6)$qx^=sobz_Zsp&YYBOS!;#1C)nThHAn9@w3^{&RXw z%paZKxrz5P%(+HCv#C0>Z*$`w*;e|~&dZc6ef9c^7UmdgVRJ6n%su8XMy$I(5f%wX zK-F+{;u)b6NP65K`@xViFB8_1z%ng=tD%}zq1LLXrlE}s+aJ11bIGfsdO3WeY|we~ zMMPb$M&_Rb{JT?*-fOGs!WcE;G){-e7m)$q5Cn9nN$`MkxKQ4FJ7+j~V!?b{J5tq> z&gw(kSQK0mvnP{zPjSsqm^5xaEGf)yXHwzlcwVg zr~GXZFw*<=t7}|g@A72Yu14{Pqi0VZ;o_c8*ojbJhAJvkA{BO`V(H%gfmowp~B>jnf6e$Bgcpa>z8n z`96y5*EZ+Wb3o#qUbh`q2Iltu&3HE*`l5OpY(Hmm zF|Lo!2tbBXe!xYnj!1IJUoR$Q?{AdzHr=E}{vjadP(k zQ?A_~9M9k9rHV&;5@2jbu)FzLZ*6rF(d7 zWM0B!_u6uzJa=ywf3`eKd}Zj16k&P&q&1eQJG4P~4YN}XLeE>%2pbO#SD4NQ&CShy%Pwst&IOV~-~E`k zh3UwFrBOH-tW^%iW=APXG6 z^d+8P`S245e-i9UexnGJOVta6IB`Oez&Lq_x8N02y3gEl(=mUGeMrQT+iuO%o^v2K zUcY?n@Zd&^^kuz=b0$aH4Y^62w~+LwmvoMY0w@cxCT(P*;gKe3RMVxh!B5}(#o?9k z0)N^nD&YJQ@Fdk zvR$^`4Bd-$Q=KY2d^zzg^q-rD8Z+?3_oQ^N8F(f5gb}Ww1n-|frnSE$5QcYCV&5v< zD%2jjsM;-HCVv?|5%!U#SHP~)ZAlJa<(%)iMt0NuOx4Yz0k4_{yQaU4NUTT_sm@__ zsL6D=Hk||)&SpqG6`_xi**v0~WOvIZ8>M4jdu#uT2nGCQ#Vh!LBwDyr>b@5kS1q*DynlO4T6|+b&#$SqZrJFvXN3Oka+97q zY5lSG=j#u5t5@vm)<0LTPYzl6o!+GLG$_m5m=Qj;I^xabJB_B`@a})4cQ>_qBn{iO zQPV2C#wzhs@Yqi#OX?lJx*fBe$k63wo$pBw&l<8%%+uU#$}b(eD0_Ba`5KQVhmJ?# zCzbQ(`Lk%VqTDS5pf_o;Jf>?ffR5w6O5WkoqI=p=9(`W;rk2bL%N$#DThb1+wj}-6 zW8$cjZUBT;lXgDs?A&8b(sw;Vp>#BF5&f=3^YlBFMu9In<1b?N^K;azY~7VFk;mY| zt(vTxtPgnDdG!4yv4q!rbQ0O_&{`cZu@mg0@Cj8Y8qFJJY!;v@7-bZA#nxtgU`pYW zQ~iEQ2j>$G%NH3qMmESM9rXpAm9pPY?AN;e5z~9;mxL9`B0 z3+X-Ad%Tw3j^;6hI-Z6TMDM5MI%ySkI<{Zuz|HuvY=-G0Dqh>8N_s6VCozS_=x}p1nQi*F%bgsT~%BTHnf9}59$>aRi zqgOU~Jlem-cV}KZwaP!q`t_$@LG8HTt^6v7c8l#&yMmfCIrFgN}Ef?c4+35YZ3@T#lwz{P_w3lzE=Ux2e*7g-o@5kPc#C;3D`3lO@g6$V~5B7;ingy3ia@yFKyD zb7dCaAb9N8#isYW%W2$`#@xm-H<{0zuU%1ySvt^b6tgsxg!~VClv?)FxgrxI*F$w zso$r8Uysmn7kcO!-WWDUCvdMOU-3iwYiYZ0+8I66TvREB257y|4A@unwn`z~_{B+~ z{r9~>X=u-L8wyDi*=O)~C^pm1XpQZ2P+5PI`!1AGd!jisLwQsY*^nF2xauCvIP>0_ z?=DL)eX|lg0$FxkXwkp7WaIQncs8$eK?xOWbE}4?V)n zb@#~qq{%VU@_C`NzvKU<5IO;0SC8N^DgmqS@6%DH)?DXhqIzpO=V}~Fm!^tp%YA2! z&K$a3x}JO}iT=Q(dHQ>=E807F!d!vKGwEi?|NqyDiveBZHFGkGN*p z+33;c2vx^YGUfY*+y`k4VR#~aoI=u3vsx(c4_;#Fw#{OLPhR`6;^bWe8H?O6YX{^P zaWK=KFR=b0qHXr1LeABHj98#`$JS(P>ci%OEUiG<^70B}x$1PP&h+iNaZZ$)Ugvs299*Z zMpr&K_w0VrNa;xHEo$6@aFb&%&zhu78ejI!9WOAK&Z!&zoR}bZVJ3dYw`Zf`XWLA` zh3U-YaKl9GS)G~SPF48Fhjp3T+hS$Mt)@$v4jsc(Hl3D^?wo#Ft$lgRY?$e?;CtuE zPf4uk7pLQ^?p0MTyTT#;LDCwjTJ@dN!)KRQGva+V!(F!U{oR4I^T*BCE0)3y6U^7a z3HI|Co-Ob(L(YHi8oF@7df9c7>FZkdvhh)4JDH95JV#l|ww9C^x92@JKYjn|F3Q;< z;(k_&hv9=%nw-9IqkMhb>nSGZVC-3`G@omIX6u)IEE3Dh%hd~?8?Jx+I{~%d&-A@E z)BOvt({Lb%$04cLH%VG;JbpsC`bgSZSxV1^am5*xndggb2J}jJ7Tki^jn=4`mV>#> z0#RC9p6M;B`akVKd z&t*SKb>V?)=E!ls3y6;irbvD<3?V)XrBkz&lG~)Y(X|B!w@4^-Wgx8eTR5xJy03-sg!5v$ z+YQmJUW1x1UveT3Zs)fj>*zV?XOsKu)zFt+)zY=Dwdvgl`5ANPb{_Jw344t!3+sv+ zeXJUA-q$Eb*ov>08H3v!OV_@1QeElQ6cO=pKbw;J8he&V`nQiypw!IPgZ%b6f*X?6qB$9m*PG8e*!R>MLB-KkxlxQ;SiEhZe=1C@QXOd;Z5l15i8ij5)lA_bUA9>KXdlJ8Sohdk$F^R?hR@xMe(y5Ihe$ zk1e>H{LRoU3vblq8xG{EHlKRF;p(v-RW&G|#E}p7A#~Ps>m>xX;vwA7j=R)pE*kRE zh=s#9oI0nnn(Op3Eq#nt{5Gk^3=VDY`8z?0k)>iin zm3EHpANeayy4TC=eF~^@Au*M;?nlQ>1b50hmN#>kx{p=nA3nyN;H#VX{ljA`&ttWQ z5y=a!&Ob7E2e0)WiRf8)b!rTs65l!*$KxqDV$~eu$>Di)t^2^tZTJoTuv^z`uX713{LT3^rp z*&gxHN^id>ST&ytKtX; ztY7HZM-n(;n(;#3Dz-z5S5!@gMgcZH4kd{&XS7Z1U>A=N1y$UZpo+Y9tdIH$D#nBW znTY$eaU~M|0)pJ6yl_3ZGK%oR@Ipq6k~35J>C)?Z44bSbS43t1*(T64S4Ewh|-yrb7H1ZF#5W+ev|peh$xw z)Z&^N^P4AA)6zTzS?k(J?@{xyPP~XXsY;`&LFPaQkJ&au^Ns;VjH~yGo{Q4aH_K|7 zZl6R(Ltdi;pJ39GV#iD?EM$H&jU_JVz@Wlz7(d2h_a~SJ10$)!RB`V=1hVmO-Oa=> z9HLOAIjUAdnkosGjH8+Cjk|!+fD&zU0to z{=g(|3cmd(vlKazmxU@5xZnQBxuZ-dl6#bV@PA6nT)TibsJ15#{3u>jzZ_Y~jS>B^ zM%o_)6dG7@v++n#wV>se^0A&Rv2e=fn+xSL2~{2JxegC~^pCKeltM93DNx0^+(rh5 zviycM;!tF~q-}U@+Q52@&A zJH8e_7W&7SCga_1d^~fARrc(mUb0Nz@4cz1scGs7i`RY69^PKcIKh?>CLad&xOPm{ z1{{M1rvkPpPuQh*_|>6Gu|sc?G7r;T+luS@tcfJV+u~&xr=r=4F)uNH2ScxCBLg?f z&K#A{M0n3)PXvfrHnv~DR<0f%{}4J>+N{-n%#vBUXkbn&EAUgpbj66o2w=7hLc&8zKF>Trn86dw&P72r*wY&~wl1GpfiO2mQRDTKHs<}gLJ4&+u3_n| z!tu@tj_hl`6L*qd_HvMhtH^uUgk}o1K4G(AvuW(Ug66+m_Ln@HO^MXlJ(zeHGnl2e znnQkQl$bygkKnuQ3vgZ0*P^eVU=|}z9-=s;M&{s%_+gGJKMcFPyf*p;rp@3wVw3XM zDzF~9BFF3w-x_x*7JG%DP=n{JzR8nGlY8~8u)wXSm{F&b6vP2a!dw`&qJ2}LMDoYu zwc1q#NZST5^>j=r{uHF6p$t^S0rzFYzt@QHwi~v2YF&TJDC3VA?fDbpUBfyf{3ci4 z4Hj^9TMo3`$6(Yf>{1xv<~P4K(31pA(4W>cKuM4M? z7mXc#PTy9uiuXWbL&B%Zo39$$g57j7spTK5KA?;Lxf#cZ%&<1vBYCa)0T&r*+t&_W zCV21}8guuFYh; z;xTTWix=UuEm8WzLcyQEdzHH;?S8}Gn>~f*f6f(x4*J)oBy#u^4OxKy^(HiU*7}30 zC7w39I0LD06lJR%g*><=5;K0kFrHRn3J62Bm8njIP<{`A{jn#GQ1OP1iiR|?(Oq2V zAmiCc%Tle|ye*2aA>`%Fm_OIz-$4dqQ#JrOVDb zaBESkj<)=^+saN?mv8q<`BV$nP5^Cf8mrayS8Gb^PX`~lYrSob(Ry3fkZrkvb#R!T z*0qy)looTou3Csz1x_7BQuL5DSn8ka?))hJL)!n%TvZVnZNf|xEo+SUt|J~Db_ zZr7BieXA@gkEGeGbj10Qk}%wTOA~+jLORMHrU2Q-Se?$J&&Seiu>H<&Z2Sp#X#*)# z-f`r=Me&j$F-%ENZOtSK;xs#_q&Aum5wv6V4ogrm#s^$~{XT&I7REN*Sop23GH#8J zr%N-m*|2)ob$z_)O6JISuBZ^!-F0e?+iafF?R9DApuM8CeWga{WI?7ci{xWNvBy!q zi>#+N1_IL}ZWoCp$m~_{>eh#;7+;z^!3c{LtCLefjbdzLWb;wdyXf_6OSeQeW_}05 z@ojN8&-ojD`i|X0H|MfTOr2gu@2@J%o!K7$qAKCVe*%mxNc!#_jC?LBytVCajs*j2 zOBAL9mZA_~f4|5(;!(y_a= zedZla>;wUY^pILLPM(Uf)*uiZnM{@LZ#zZCJRm3tqX07!cZPnc=|>Z!w!J*{qsbP# z@W*+c>K4mG)~V8?0$;cNJ8Zi)U2n3&P=0n)K*R2*YkVD94&!Y{8@iE_!s`)f=37*o zF>a@KEUmgX&4cI0g<*X42!O&{-S&1h(VvG49$&rgmTsn(0Evy}f6x7rp@0b)^$?+e87BmZ zrM4PL*^Zj5Z%rT4##MRJ3w_(JGO@76)Q$!<-#1l4EVkNn&9XJMZJX@r^y-z=Xuz`T zF$LTor2OF#Bu2Nx5#M~%`%XNIB$0CIKfM0Fy<$VGrRbPhDnN5pPz!lMqz$z!0mmu#6X!rVk!-<+FE(0 zl^&Yk=KI$W%2$mT3SKp-gY;-XJ20nj>=k2E`zo{B#AIP6Vy|OKNB|~?qV1FOqB$8M z8c%dx?+|5E8#bpRV>F}SLkH3E_m5*BlE8GcAxH+f?JzmCRBW=oF@^$yOe0O8ztR=E zH*$@IXTj;^FiUcnSfPE!+!X9;DheD1$zBw;2S2(GK0QfEA3;)iD*Xll1!@5b4Al^H zG~;@+d@Z*0;AJfg1(ojp$n)c!PfiU=Ngql|3bMa8c+{ii*DsIn-R{1=!zpH4f@meo zo36O=5Y8gs*CwmsW!q`eWUnz_bOP$eGOI*EkW+Mi?a0(`=tXb`4fLio6R!0}jz)n`SV z3lj5G)|EH;S3=kY1xdVFZppaZ%-Tno2I(XO0AL^|9QXRp05{<6F&UsEA4^lkj8@`P z>oh;jOF^bUu_W+Pm7?S&f9;=CV55^(ZJ@R5urA9@lvm}D+IDqSRJF{pw7bvj@CAwh zf7_Qxjs>49&Sq1~=r+ZuiJ}z9708c^r2bN`arLxtHz*}AQjU%qdq`-zXYx62@YcTr z1XthOudGiE->pt3o4@yeEp7kFKgdtg22u+d7fudM6GW$kp%B;LBYntDMskmwv7b8r zQDoe{kbQz?JS6_$oMv{Et2&`%6U3~YPUxEabcOx(0dy$TXz*w-k$l|Y9(Rm8hW(Kwf@!n3b-0mCJ@_ep_p8R| z`y(+JH93l${hP6okw65g)AWkirjoRmpBNqEihl3cQN zOX}ZXDM|_fOX7QADV=9Yj;3|H(#PDBMSlVpB&zWH@>M+Q^s<+ee7#l((9h^9S`I#`Oe-GFWs z`Xd4){&H@bSr`(^LtqGPRPjH_Sjidb{Mo1vFm)RxH<$m7(_;GBz@HC*{{c?3h3X}F zUkDBV2nz#TUKD*V+ZOY^=f)*#xKwYe9Fj&*Ho_XtH>v!AP)1U)Tx2jWNt+Sb($TF+ z+f#ZN^cyRFnu$b4-TO5wWAdbYG%zLVLq8M9V@Ks3Zh8!|pB3cu@pW3f+#8KAEM<YA=JXt&yZlEg3i@N@e;Q+k}pr144s+L za9JMX?#_8<5Xiv#7m=I<>W+{1-N~hlANZs}kI)JL$qVRsi@DI|^x+vn%OGAv@1QBI zyjgLRk9o@}Qgk)?$`E7$&)|!BkByfK)kwtH3^~xr#M9Zo7~51 z9JIlNB6#A~w0}KDR*HEaRKp)-;*pY&0NP&@iok$?WNJkk#utZ~0$*z=D?=%v_s}gJ zGl~iOASx^-ET$m;wioN5qg~C`cKo;xyWxqbOgX)>*7?ZK(!fv~#wpeV9Yaw>}= zARobH{JQ#rsPGg@w`&T`1eBLyv!bCAyqCr!L*?at#kpI&*v73NZ&V}jjWAD7FdUqh z!UA412gt-QM?Uxk*?NB`ed&#n`GWthcvsf}MzNK|1qicDzO(vl%J>TDr|ZLR$F%c+ zu)3|eaQQ^_T9;+tx2B2#xvWy76-rWysU~m zb!#v$PFZ;3VbjJ1>E7<9ZYDQ1d&qGl#73w9B}Gh^O=!mR)g5L)1pI@Y&-OrrKjwSg zvMBmRwq)w4DB2(6-R1HG&Ma~176%Q9e^Fymqa0FXvP1OWIC=nH-jMOdrm7u}z0Z+I zPS;xFX)uFWg_F??zF*Mt^L`qpRR151=zyoDmPnj#oHJvFtSAR>-J~ueY?J0DJK`|0 zq1Us%bO<8rY- znji3l@cbDrUpC+54wWYDfH%q)mXr`q1c|OR{J!}u$m@iiH=^I#&t%|1z&*vZPol4B z1QBq3U#4$CB$F_6U3_z0Spnh%hmIEaYq`hDZcY5tbZAP(2mZ;lO|;^FXWP%^#(R+5 z`4It1| z=yKT|$Z&3s?7V0S{;X{cGDcl8w?covKNv4ffj>tkc6Qli!v79NK_@sP03k34rzeyb zZ8H?+CkSeJo`;tJQPBYtpT!Y;0tQ3Ei)t%6*C3ZcA2J%8PIB%S0eJ(! zBLggtcz`D1DJNd00mep=q{Gz59sOzxneuNK>V?2ii9HzVxRd{(qWxI=Z~cpV3lsaJ z>;VFGtS0Zsfe7`X0EbGxakq{RLc?jf0w{3Ti*$Rq!%stJc|V~laKDg?xPL&g}BWaprxRB+@?Ny+Wi zS^T@nXW(mbpG2ktDS3&#<^D*F*DecaZTz*3;piw;yXbmRgol2g|Dg0UEP?X5P<+$A zt&Z3~IpPQ{|Az+(&s+|Ikt+I6sriv|AH^;2`i`O;tyT=a8{ELeP69^=I&k zAb1!)#1#K{FBsyw(v>EfCK{$^LQDZ@*kms6d{}fDFSsIO7$Z?}Xd+l_zkOg{6&nQ^ zl)yF!^h4}uw=OWZavI+k;0Nr7d zcckvai|zZ8H%h^B5;9CH7CMbclvYnDx~Y zB(Y*ka&obeMTfYcNLp>aGg^UB84mTD92KBCp*buB7}CPZ52RK z8cB-AS{>1VV&&GRja;E;f(EyAsliAaq=>J}K>JqqnjMkK^Rwy?GeHnn5}2zy(2 zIFbTYBBjVZ{A4)oN^1en)sky;;4E%mni+MTf$N;>q->&8BwM;uAHsDmh;{%)rv@^aW7 z?#Z3IQhZG+K4Ro<{>AOnRj+H4ZsFZ#^jk9Nn;jz35-n?mB;b2N(lp7l0!OVp$_L9k4v(s=TxBuZdwIfz7#_lOh)y z@$7Ri?uoiGgo&b$$GWFT9Hcp@QISf$r|Gb(X|7g05(P^xe}z#~+6VN5h)d2sQV zhSq~&kVd80k*rXUBu*vFVP3VpvGWd%-CpT+by%X!{uHA@(vRYOQ%=#(RL4h$B4Ph` z(eLxGqW|q8ADt3s*y-3TU&-U(>`(n(XF`NNx3iy`gz_;NgbM$sCOV>MZ&0KpICA~$;;ZqkmXXKONqwAuHBOP3;T(kTisLDHXE?L>l<=0cwxKHG~^To3|kA82p7nFj#W;fLcozmbF*CI%j1w<40+(fnAk!N z>)Og!lJF31S6JiWK_=YQJ1G>&6v*6m*~SpCR`M`cRnyz@0LeN_mgDh*#z-k@%NH3g zs)wO`^y)&87y}ux7(k{TPlT9`NPh?C;Qd`SEws-(n9)RlP<`WHNk`Ozr;!bCGh$gJgu ziHInLh#61{ByrAK2dMQ~93lRaAn_L-Lef>nIQs-f@?;o-c<&&)!h5bsV*U!_L^H;A zI{zQW-UFWM_kH{i$KHFTj+N@DP?0Ey?3PN$o>|E*WR$%(2^k5MviFu*b||9ktjvha z_+PK1-tYJ4{rP^szyITY)HyiLdA;uYzQ%oB&+GF2*>2g-vB5>JYl}Ka9g+KreLpvW z5|jI-pkYa8w|M5Ybev@|NBq%irMhE3rz=m+R4%SPzF4W=y4E_K+UVEPUi)27Yt{Tt zhDg#%$?-QrT2HqFvOa%txU+k(eM~BKWFU>drsZwiog{@8Rwd`6gYvkA(+33^ScdlZ zuJx+9u6oxj-X_Vq#C$>qnVW#|RVV)L_0-R5Dbn*Tdr!%^*c3 z@~x}Ux`a8~WWC^;L`u=F~bM9-Yi%%w>nQrLXF_ z`K$S>iLg*U!$_xI>tyaoK6Q~|o}yf)LZ-qqyWvD{A!ct(!*}8Pkp!JGYJBe}4<(^> zxOL+Gq%=k-N(r<1R5EIrZHToA)N1w~M2WLw?^tBpKG}-D=kt5;Kg^R?>tw!1tRwyB zA=~o^5&>=`(>wQhge@@VY23EE{xX~zwS+dtBJ}NEVXmtwsx2Jmmh0C#ao~@Y?8MF} zugCDh=elFy<0Hp8dz+H`W{=tX+#}X5Q#-oiHLBbq6lCWE1Gy&1mHd5e&)^%~Q+}?} z^wF4+z_w`BuE)00Z;5?ejxl6|ZR-m}zG7!xSy_Eoimr!<=}3lV8God_smYlOt*aabP#T|d0sFy+nY5z zwo&jdzg~GhV|;da_P|^)tD73c5A;4-0+xY5ZJ^}QR5ewibM%*5iCXqbZLt?ecjrm!rPY?bWbi!Xm&w;s^B9*>V_ z7WSP%$nVCXR}T|(MB8KHXY3aLX(}E5X)4PYa#U_)Lrk+pJEDx|uG}O=X+HVkUpbA5 zJMm*yUn5@r@S&b)H+W!ObuTliw0xi1VKvd@lqPL*QZ+KQQqNrGdQUR7+-S+G=ubKI ze@RYG{d-yW|CAYn@&AIEhFsfeXwQBq_}cMZ_{8UpEW>h#`ShJ9nX|?ldlfRNEcX#w zF24axiD6-k1?(-#D@nWt+j4ABtYFAF@ZhF=G~_fW!1FIoW>MyzBJ$38!VFo~dvS6-^9|?rDbKAQf-6{-*O(MixPT#4i}j3!Ie3A#;Qx^1d*pEY zo0511_7~_E$scFw1}Taow*+a+nJtV@7K`;$zzCFoqm7)L2)2f=Y`R^BCTR^{m5jCL78|906}Ng^eOs{o& z+LhMQw71vOv^j$}pZ^y%ghC`wxzC&++lH8(xq%sxmUMJCGcs)WpIhA+r$g;ZPa^Mav-9AC3kK~kk`958l53%$N$UPuL-W` zrTKf-2G&PwPQIWJnm?N#zDukXQRbNidsQ!^3|1){ZQ)~M%&2&_*fYzhy8hrKMY&@_ z3v#ds2LpZGC)U$2pSb|Ga~lPZwlIcFySeZcx3;-~O7$eLwZXC7;&^w(Jg@jpH z3_KW8{9tUxEl?}=AvUDZEiIQVc4?!5|A!o)qu}#UP^mU}y7xz4G)3+$Be^AzXCar@Lmvn&fIPpTT?( zYI@+3naw7?&CEbj}LHLHbx$21y1vB zS45sMFKDvUgaoFY(!{0X(K=2nO68H-j@DP`N=5KwgG%zpsfbCG&)NJRDE=^9Qe#qW!jQvDt!G*QsO2G-08f$Ow7Gc!`Bev| zmmpHhR-zMGvL+zKop8HL#^S$OkHchH-fm)%pp1}##l+jZvc5!D7`a9x<{{3bL0=+M z%#eS9U(0~J4p&`&sYK9;rI^7eI)@fL-{oZb(P?<`812EJ2U`!nd1||+5A3JfExMUg zTzvGalG`kUyw!i!O~@qP|EhoT53{dr*cN181Hul1?^OE2)ga(La&phvpCO=|JqDU{ z+u&HSOtImm&SS$_87DU8xoWA~Yfa~Cl*+`vB|Qo{`1H{ouWN5sW;;4M-al`-|5vE@ zccLA0zUUri9ty*A2JnU9a<2=Ua80NAq%ob!#R5Ne3b#yzX3mL_N0`ITDz6v!s=`g~(wU>^0S zcTJk$%^PK*G27TCL<6Qo-#0QAV9-!n;M-Y!5)I8W<`5w9P%pTw`t0-#bdTONMOhGQ zb8B&H;eBFhxF%1FW?W75<>{Z`zVj~*eb}A|FK1RN_Qo_igR|c<|DCIf zZUr`3KSls=$b3=Km}}>))9Xixk&h(o_~Z6Qc=YAcTZc3Q6mbhxCPRq5zkL|@-v96=JsON=1pa;N=vKr}`~olz zUlQwlYE!P3=9hNU#YAzxNq>kv;_)4O~_0 zxkkE2hR=M#XzqW;yr(0P2W~AT?HJ-LZ&?hLbUuzpG(8{8^C|W-gu~!oODx@< zkEFb9NWJGP{dSoMv)HNx8%1YsCz=s!NaMnpjfgdFpB6nmH@|7$_oo75nZq*T>Doi~ z<3;N#W#Vi*cQSM>EpNV!+Ub4Xa%VP5D(|Mt7pwW*RE=%Z?H_K|)h2$wZEmb=%SKl1 zX9QMSeX&zDs6FPkNGq}UGE8#>sz&Tu8GxWKjUy<}!?e*fz%atnbtyk-)aq0g%C*Zu zXI#%%=)I#5J*Zh=|FQ3Zj*e79COAL5@j-4||Cyei407AF+%5XFo13va_l47wQ#bT| zxyS#_3mdKEFJV1#gld#ekh_+~B~|aBVLJ0YGtrpl!Y54>%`KDnsXd|_Q!3emoiCa@ zN=k6CNap-M;lNXEIy8y;TN6QJvu?d-L#rMdof;>q!s_{sKpDh%@rJiT(G1D#O~s3f z7e#3SdPw?~zl=nc0+Bk;m(f^SH;?rKoT z2jIGJbBQzW`i*-k22^8Qa{gJDLR1mNF0n^phlg@33VM3Vx``toJ&6w05uhV(s&&wL zdGa|-_;@zxT8*ZU9&WlaH(JpwEyZgX><__Kl(ZoWC0&DmZ041Z2)%`;=@Dqco9oaZ z#TCc}A)qsXbjl}lJZSnG==b*gUe9+Uf5SlLC_sQn1}3xmv=~R9kJ;3(?!x?a^XRMp z^Vv}Z|MIktl8}HTBf0KMKl!0xY5Z~13ow-~8k47+Q2~{o2ZXo>h1Q;|o&%D_e{(7KnywW{A03|`?*Rx98ujEugb-+x zjfo$M9}FV156=mWviW}#!Y9n#(T~t&Po@5N)@-lE-q=?=An3!qKPgPj_)QUbD?G&v zsh~3mt?V^qGdq{2txJ>rcYdje!z&2Moa`l1ywRiY@3|GxD7b|lylYwUXha7@;-ga# zz+T#44ABEZ0C(P3+u`*=D=FkcZtoTzhCqObKVv{>>1r2(G``S07lD@MMerBC_COgj zWI)b~psed+kvedIRL*RW_EyB5D+BI<@2)W+34;om;rZiSiusH0Q%+SUuIxSuMqFyi zSHVHQs@7i)J2Y=9F-%BFZQUdpfA~0QV@v-d0$a;1nXLr9sp%SaSRFQ>k^1crYDtkW z6sRMqaYHp4D!x974{(>{iIUSmL7su6(Rk20a9@z+g@|~7?rVes6ETCF0Xm%ek;k0u zlhAm(`sJF@(zVbd_+V%w08Z?x%gkgA`fR$fvUdWpe=z3XdtjOa78no0> zN*qyK@0s!iuzC5Xk-;5_q(mCZ{DIxl?WNJeuEmv5`TC&UZJ&_y!4-)U!|&5}r$)X` zY!0P&Bbd&Ho~H+b_zED1Z}Th)K_nyX!xSkP>_meV0bez0rG!laIpJ*~;UHo%KqE7F z5gCU>xilT%5+_=uVd}qrk%O!!nHWGQBn;K6NUGAvCIxaL;hAS;@vLvdeeDP+O!&UB zvC+tDDy8;s6k6i~QnS^>{TBymlD7|t50U#*9%z$#$UqZGqf#dapT|-&4p9A=K!2X~ zc3(Bw-bB>sLLE{-@TbB{7Pf$=N5hF8WV5g*oIx0p<+IWkQ4wTtXJ+TEWJ&gT))|C= zgp+l*M}r{b__!2t0_I4v@V3+~bemAzaMUeG^+|@;=*EtBt3x7!Z{Q9+A@JkK(+nac zpAM729Ue|Lu1mBFC!YQcQOshO}vTm!UO zKDFFmdA4q`^kKP`RW4xu?*e0N_dJP08ZvUh9TiZ}(yy<5XCOrRuy5k;vTRRP~Oi2C|ZVjPb zGLjIg5UREC(mEjaB8~1W7eK2b2X)SU9yfT#=AS1Nf2+s~$w1k2{52tr2Yyco%uf9w zIUaKxLPL?`?26@!SK*W4xFsAO+eirSoIk^kV9YOn;d7}?L^5V>X;gf-$GttEp67}NJ0j}c6i>=SqR z!8c_g06KaA#h~Jm=CVJH@EIX|GB@(c@HBw>DmUbqso;l3u1Ylc>=H@_6=@-^fTat! zc>wv*0(Cqnv>YH~u*do=d*k&r#Y#0P0R#ddmqx#kVJY;U=W^p^m%CEI?gQ~1Wr(d_ zHb(Lot^868m#S+6TQ5v_EA^7!wI;~<_X&Wq6==1xYQWr({IVzPJ%sM7mAJ}*)D$7# zc4p=zjv$RR;5<%?Lj9F^cy4Rj$!V3C_^9rDDZg6P=GRL`ct_7*ZbE zy^PW-#!jREK!m`(`@F&#kd2T zQuM79M0NiwP$ei7eXuea6f%%V%gkVt6h!LBX`o1ID&>%45EdkxA=`=$nKM9{KwfEJ zYr(rKzz_1p&+%|8{w3Q;!XBTuMAS1F0K90|Vy9sM!vtG9GLg;$uvcNW$%|u$;?ghD z{aRS7O<&6vkAKRdxLH2O2JG6n(^q~*WC&u1p>01uV#ts<)1Ao z0h^t9Q;hYHGv84R6_;W;b0Q7E@(3IU@-z(~1Qbf11r_;{#kMQ#&5>-11N~7aoRK=E zs?{Xd)$uR(bqGM0Nsr{6E7UhPzSGhY0PFi2t8<~6p3iwEI0 zpeD^ABK`g1jlV=Z-GQ&d%EG*%%9}f!$)TpzGgd3f}oq^m0RZ6wzoY)q!-hjlRI4IjrHgsok- zDom!>W(evUB;g&LAc6H+)qrH%KGCV{@7HLH;fU3p*IY*A4{JR|QMdRf3rQ;9pgzS04iLB}m zpa);oXWes0^^I4*&M_40Exc;YQezK0&-C=zUZXSjzbp8ONf>gXfN6^{zl|Pt3;F9T zrZwo4cdR#u6%p<`Yk_S3r@|{Ak^lC-#;}oDBfy*i5tJ2CRuuL-xYY{CV1RB0vXX`q z$wUD!U*MtEOHE%yf;NF}WVumwUv)D;f`|y9(}nbRR8c2LCwm#*;$fQBLPP?T+-k-bcU z5EIDYyPnHUCm)+YdYK$-z!?K%+W?kF;Z1=8?GN0|tD`qS_p5l=)HM+{vjKbdsq)|F z&QIyt01^r$GJ4Q?cvrOWBb$hh4uK`Enl5~=^}i5uJ(@l|95p^<^p_gYivIkir+|9l zTD2z8@^&?`)R5&s(U4kL^`M>KS&bjHC_S5_bX4BRbpTXihghZNk>Gb^^<+^uf(}#u z!A$!pt^g<@^1BH7xvcTu*|@^K{r}Ox%5$mXw+BI7mId(!8SmC}_GPR8tXt*$N8Ku# zDBx35xQFbC9{eI9e2MJq7W{K8I#}r1S@xsh>#gqrR3h?l9Yo!YR7Efp1is*_p{F5q z5_!50@EKsvA$rOTl+% zjE};bOqR+2Fx~lBSO{8Q+CyHvq`%)96)9ik3j%pr0ZmeuTdPQTq+0NI#+zO17&)Kw zD|xWW{?SAPK;O9i!naC#*wzsITou`lFH&?RQ&JwI>PWy@BNF(&-Q*#3#1FG;UthCa zy4g;Afr#O51tl;N4B27Qh+aZ@Qy&tQkOMeVh>(YjZlI_hG9uduNmE50&WD;txB_NG(eR?HyYriAw~2sHn!0ds(F=mqfHTw_JKb1pf3a8kK;b@&HivE z%{{n}dVbJ+PK?Eu4h+@0r6N*z)R|A`2_-k8<08_AA^=g!dZuYy|6TgZje=~X9C!fV z#DsT;4mu1;wVW423S>&q2x09KpK+WRoOjV%j-X2wJH&+Tt`W&V-I`VGc(KGus*{&W zQ=#4nl(q*#`U2#PkiPvkY*c(MbFyR%;U1Dfz`U0oNiPR@b1;=Jj{B5 zAY{AP5O5SUPWzLLcf%8;<}IH&fy$c-4q#5`#Qu>ByLVN#|MmTma(wD?N!>vFl{{GDpRe0nHcva@j{tXi4?vZQB+zM*TD9+`xSU9Et)qU=mlk^4xmyla$A9&`vj5Xv5H_hX{_QA!YMK(Hs1EE9V z1P66`Q9Bq~P~y$s$oxDyJ%s9AeFO=JA_6#yJzGI-?h&92+qsuP8AU#9RfGpZJjD;# z?PZ@)@8+w1SoofyU>j?m{nBY|){|U&kic_y@;??tf3yanpf9P4gnQE*7=zPrX>(~e zRwVnd5ioi{RRbecrHW9Oo1`>wI_AqEDm(?K7e~`C4{|9HYQAqrBxxySAFv#uJ3X<= z0vCWNBNP;*;(zBDFJ6Zv05tYW)#4}}nNdAGgnJ}Ej^p(9zdrNPCIk#PV$A(7w7_i~F zEAq|h@xCd6^uto-NhdzcrO*5cP-E7h!se0gTZj7Bir^1fgFFnL-|NORk0Gq$-hl0n z*wP{=LCaxi>Sv?-Dts!PN7o_^N{83WsxzADZ#zAwa%@ z@TWWfOCJ-Q&OHGPwKJVd2$8sLfU^sTu7pov4{XdRrH~+CSTI9 z=&Qv8bY%33L;ENYH>!$-9yx8nQ@gWQ86ma+g$L(j!_UXM=&(Z?*ciImWuC15Z7(l* z2V4Q;(FC9&aUh7_KOFY|#PNX&B!bF~R@eu~%Oi+kj#}XX_9q##HT(quQmssZ^Mdk) z%NxYaWQ<|%1DK;)l$+tiGQ`)xeOgfndZ3E*iIx6``^2nRDMRfc>n0`xJF%vY06}9l z(5h(mEfMe?5cKdUy<+)l0%EwddA;1>+yTzvr7MowQ0a)Y@Sr6DPEwdbjR`u3B*3&H z7SIC=Awf@3Z7pJCvby+M89)0>K zK59X!Y<)?oOq6Z);+uuJx$VE&MY2M>NN>b3Ra{R+EEXF5rx#Pn=N)KFbBo{93rIs} zNpemq!pKz;G5Q!1z8?deqHLnEkT@dYGs(kZ`}DirCc50o2tn@Ok$AbY1#I24jgS(d zWF{!{xOQG^0XalxmKX@_BO`CJWUe?P2R(IuhjuGXQP`A&MM_vjEFlZcKE6i2k0;hJ ztrw79KJ(j^_s6%lnT647#eP8~-$9GL@co7qZCqp5<0U9_6m3Sb!5Q3o=L*JO)HX1C zAhw>oU-`O6=Hs?AY;@zVH5Xlp^yeS$13`;?FmVk;&`I~RCz|_#5ZXVY^wnb~IzHX~ zGgs!~N}H>s#lfwsD-!WWlo>afz$G(ccBHTqi2&V0L3Qgk{sc~7zZrpxEi5TL6>bLc z8Sdc^upY${Aa)SSVncKTY`1T3mZu^15p0!*Jha6#Aws0#j|FwZM*f38Ux3!=o3zs! zL;zhrAry|Gla2$6-1w7}er2!{G^6KJM8*iYFXFtrUzV61UKq zLUA|lAQ$88b`d1_?4OY8SlmCr*MB!`J`?rFCu}q*hNzO$^{Rmz4A*W{w)-F_gj*1H zgvBF+ASLpi-QtdlM9qBE4f@&!XeAsIvfWX2;QxUG0?#5J(q4dC51YE!U`j;$K$z=j zxaqL|$FWHoes0+35yS|Y&iCv(!p-iTn37Z4NEvUS>~i=Fkcy7e&x}?ryx!rIFN7rd z9;NiA;M37~DhPEWAmzMxs|`-LQu7rM(8wEphiRF?njt{3-GQJAMi)UVyAvuPKIEU^ z)Co(CSNLNp#va~+h~pZ0D@=xjL5HM{jF*zHA0v#s@=u^=&sGqUYdpfMx@X8a_MV6= z0x2UgjPRUR%g^eKYBOWgpMA1M`MuAeHxvD^@p)Dyt+2|mU^eIVCA8Bxx>=L z|0bc0&jK&-6DoZZ;C0DHQ> zyJX{}D4j1E-<|dlbhz0*sP#FF)cRNmSqQ;W?8Uq+gg_X~U~(imSvcrW-Xz{6C<3J- z_bB&$Xg>7QyH(IjDRk*~FC~US0wmKzPDYL>O?Ob54B_{ocEBkR`ZVAH$zPp$&ODT} z7$)@lMXg07T%z8;x|&_31E=SUn)UiAcd#g!6R7Y*CL0_~D$r3i@YL??_1!(R;L^J@ zcvp}PUu>t9iQ){5;rr3)XBo>H9ud?NN%;D2Uu42hS@4lCTw&c2Ei+ z#1=Hy&OtQJ zJM6eScrW|N_7TEL?^8@pp>p>|q1QOp@F}T0rVLZNBW<1rp3M*YBKFfAXXBuQfn=oM z5}|g~rWP5QMdLw_!G8rZmS68&SNH|=+tJD4h#;8|KkUM>;eTV=&RkHqL&ACw`S?0! za~{0I5J43Aft(fu6z+@O1NEMOn{cDHKp(pQ5JxR4Rq9mBq>oTjSinSCW%W&Ol z{a=kM%^AX{pFbfd*+;H^MiDt1?vo*mw5*UJWMFic4B{i`cUKa6&wJTZX+u(munxrw zQX!3npao>Sly)0xQC{xjAM*sC)QbU4A93DJ7!*kxbttGr&MVk7cSV9DzxyjxzWEz(!5-v}VHfvBO6|ttTQQ1q zE?mp{Y;jt&htavJ;V)Dv=6>Ge#hA#F|3>~#{0sR{U#`1Jeo^#_`m*HpQuFSNUqW}< z3lw{wAjjYCNSCQZJekvd9QR&uLoJz^(PTV`PxD6l#ZKlK259yVXc~a>(M60dNMbQd zB2vpU+o*Rw6*H~8fTh$4NY{=SQZAP%N8F}o66Ee@ujoW!%*|XaMpMJHft?{lf(f-iL*YHFrdLE|7_l!@bF(DZF1`Da0OdWGEx+NO& zU3zqSDy507tV{*!D%szOkA=zq&~iF45f~uhDlP7igs1Jk6MJAFXMVvkHyY_2fosxw zJYf2Fyv98LN^56g<6nKYR%gWy^3Ts$L_PO%}` z$w6g^p$qs693JSHAP>|KtYJ<(~lC*_rlb&Y7bEq8>)1Erf$e$yh=?` zE+`SiW2YniIC`Gm>9U`g&8F$>gI`T@w4*JKuH3qd6Mr%J6;64U!|#L6Nof5W!;6&r z4-9Y3S-R7@()dqgH9h_2g;?W$LkuTx+6Xz1Hn(=!RfQ$5DU_wB%|yT0nQTUrW}pcT zD9Vex^)anSH~x+sJYOmAxP`fg5l_VCMxWXpY9mk4YJNpyfVm`nNm_5>8bW#HG7rR} zA1CkiBGJ_@-q9ZV8#y{As_@T0(6P)=f*_Gq&Z>n2$lt_BaV&dzyhIn86sx!vuixI7 z2r?vc_!|}#lwP{>P*A#y_RBJGbxr^_UhI_D7Ky@>jFRY)Nre_%WM~O}2?I@*WY9Se z@haBzQf6BWcnHNviW^u+K|uQeb8CQ2QO4D1-0%B7zY#7Pnv~%Y{yO0LAT(hFuS7wliQU7M0F3g=MDbxH*5X!KH5jdFW?g2TOL`cUnDht$2EU1K5+VmM zxTPIiomvpCp-%+GUta5z<&N1eyhkb-kzB4s1qHl zCB7CDk?(fSv#la(tk#(GSBiGXPBGhTuf*8zbJ?j@8BCX6$lp^Qc|!eha%XEh1Cwg8 z;f{!cN^xkiX&#sKw<>Hi$SBOa1tpD7Bv*;jnE zOa&&E8Mfwt2z`tHQ$bHyMzT(pt!JJ7-NbKWl4l>i)|(xqlSXE%>Xe)|%1745d7Ln{jP|X}8Dg`05%3 z<`jIRSK|OAYnGr_k%yr|cBEL6FUl4mO*@MKgs|VnZevG7`?s-hAnDqp$3P%}q%;27 z+*0+a?N5M%@iPQCPI727de#NvfZTHFq^8+Q)~v+^>pi{|l$EBMG0}G&AXpWc{dilE z#j6!a1H)V1>T)@6@Ia#VOg6rS;mRACBG0VY>I5_CTHIJ3VC3QevC5;^>4D=n1p)fU zLgMETiVYqnyWI6caLs1#>;sm|O-vdvmz;%z;+|(bVFQFFLwM#t$`P<29G%L+j1q-l zkpe){h&+4E*0Ulaen;a2Y9gYibL1bQ_l6N-yrfj7CniY)k7zY zdvIe{Ae~kUvyqRPT&MEK4`!U&boCXBNmF^RKhfH; zRNwfta+Ck*a~^G}qrdoAMr*YvG}7`~kHm!eO=b>AWZ*m1MsFdl2`-aH7Dl>Vjws}5 zcx>(i1H6_=QbM(LkDBPthiID#zd#&<-}euFm^KzJj;DbNMX&#^P-MqfD1NqB$?s|% zoq;Zou$78sN)1;;M)74G{7Kwo0QuJK=gx~3lt-Q07l!;@h(f<0g+f0>Q3Q2kKet%& zH+-Kkj&@yhv8}|1CgMDkHU|~)#J&uIvAfLrW(g5nhSSbU^Ll~{U7hgL`4(O+-+}sQ zpu@!p#7>b0$*eroRekoq_FMhE&w4ZH_x1}?OVR|GecJF$eD(hDOv$h`O(kcyAmH5@ z0DZ4xV5-L5`UBVE8C$+#7elyc-vZ{_m~Nc%UTNNp!Cvl)T&A%XDa)%1_&<|Z;l&I& zR*G71%>5@v3zaKe+|Q!>THEQELNXPAfTvz z3a#cjJ}bhLg^`Y%D6lSuvYnQCmKqqjEOvaqNApwPcE#84mt7JId|T9NO<(RDUG{mJ zb;5k5+K4@B z7LN=|<04J{F6WE*mqH(z z5*y0@OQE|sJe+OI#}`W`?fx#7RCqPDM_cmmd`-9ga5=9wG++;cc(4f(Y*CM~G5V+H zL965w_==@O`y0u1f~qm1#hiix9#6Y+o1t_80tcT$Jf3joC(*%q-0c+kk*AwvaEiEP z8afgj=nztReOTXpICo}!Vs*rjWi}9DBqA6rq9pv?&Z#*)9L6_EZfwcUafF;uT$_Hq z$5W zmG&&}emBAa=#_sn!*)}ub$5wu@mJw`d+J(=<dM%G(-pxe!s{U^yf2tdn+8bSd`| zf4QF=t}piyo6KH zk3J7GT-`xAeq$Y^zR5u_o zB;nD3)vl*PWm=T8PY;RW+Z^>wpy5O{RBDW>d}tv2sC5I0!-;whh~a_|H@g_~D&t zFcYbX_$hi4+=&&qVnBY)5Ei#u~9GLUQG!_+8eFXD93`uwx? zsS&MA7#W<^mX*$fW~se4;B4Y7)mdvle(ae2|7kYIgh9sAaLC>hCb$I>m6bOvq5=4b zjOZ`9hf{yFo$YOcOqEO{y{iY()t!D)AD15VY*FV{Zw|>2r0h1@wx!<>Rko+^tdzXx zm;0u50=?({SZa2*jO|uxWz7l{E^g)+Y~*YVW;i^i+~uNcjrmmW(i=Cx^4v`|LsX0U z&UXG^e`Dp8=npN7A`;KA3^;h$4Y%yJq;sp$ z8cS09=j)g#6)H}>E=(O<)4Qcm!8U_as5t0U=yfS^4qLJP87m+mAko>;9BO@}b=Ibh zrr<8u?Acy>i@u{F{RR&75*I>OI)kYD%YvU5q{3+Z)Utl-o&z}}jbom0hy8*fcZE?4 zX&e`+Ppdi&g+PVP^Zw@J9C>&1z2^4Mb^o}U`&PdE;9q-kFkC{Ktl6NET>7VlX%E`rcknX^oGKT@xwe>QuIK};JWnNrtU%6W8-?~2#ysJFj z_?U6Jvgw|n!1pgxs0GxMck#I$+B+w$TV5p04($KHaj2jq0?TJ}QYkqqF-m8;TTr00 z`8e-{pwX1RfPhURH}i0%z4N`_jdY9ZYL5qSQ1^@X$q61rCgkVt`=LS6({Ywtb-PE8 z=q9jc2%?Hy`gL?Nl({L2cx(iu*Is?OiKDvR^bIi8hTf`K*R?I>`zqYs$CR34e{5Fu ze=(+;j>FvAdHR-3Ys#w0b#q!z^XTs3#nj7rseO&Et^^e|#zeWPea1Fhw_E%v=R|o4 zD#q(XY`C;p3xw+JJz9O2-Us(}*Pf-9@YE4`FRD-4*C^QTt}~KP&`03lK6unG-TQS9 zs=~~V`ctjF@Ev097}=2GoXb#b_xN=5yIP`VT2y{7eFZJ&J%J@jcpGxf{Xtp_=u zwTC&VBxa}h?)=Ji`#e(;`hK_3d442!W9)WnX(#1_8t+LP!c_iBJ6{46$L82XgeCRn z!Jtje{WG6)!h)_kRt$dt!MVDX0gh~a06`<$su zTVt#lj)7M%?RIdV*pkdXW?pfow_@S8R)cC+KFMtGgW~jK1@HP?Yv!U~Da6wr)$$rz zFVu5dF72LIBgtCmdhOuH?6&Xpb@FNt4sP?p9)q*`t%Rq~gocw`q>10UNPv>?&H0=d@DPQkLuQYnq?oyp| z=1&WKTZgqD=bEET8*12@sIf$y`%djc9y$+Q=p-XgSp7;7_c-seygaXevH^QV@NJQ= z{$%{4S2*1X^ksS}_8szJpsq2C?3%<}BYb1jGa<1gpywbTC3WS%g4gKC2U7`S7I%X~ zq+1IaQ4buQ3NH>|e#A68@;-m@V!KgGB<#en1((?Fn)Is1k9fi6i6GV-)tzf&jC!Ys zx2IyB?~mUQoKVS$X%O$3ZJ1p(Nq0`v7E&oA$!XQj79*^k9S?jLrgmpqv+RZM$0r)g z7beb@*imZ}ed;Q@Gus(+Gc)GRi$```L|UI{s?E4HWTFmM9V`h-S##>Bu+6|dC|3J2 z?2Nl}YHjwtF3vh>E9AtHA4@svfzI29TkVIeT3u2^tyrM>CmXlAF866Pe_0~CUVrtoJ=@sX0V;d0LkjI`gZ%8@ zL}h7O9XSIF%BfO&O$ItGr$x696viJp6kSkKZ^@RSo$AYNb>So3>EJ8W?It?CI%b~} zDukpTv4*kt(o~Z@*C4#}AZ;nkt?}$?)I0I8YGV1vm)krd=$>;5lghV{%A;NzM2t(` zts@hRJRRaKcU_G9F?TQ@EBd5f&~XM?Ru4Ht9shd~s>))5gh7vJg2LsRc#{3+#tj8I zLQvs~glj3Kin50d=gz>7Yj|=M(^?~s5(bS=h)2rtsfnM`R9<}lj62AkhkPKYj)x$E z?56io8Rln!?mQ6-%CE@|^I+`G@mJo=IR7PM-uhg|=_gyOrYADQzSfCVr!~AXn6JDT zoKxuN<#UdJAipK^B^^*T1- zebIcxhVkvu9z`ebc$<@*m;D(IxzeY28&{BRj4wzB)A3Rzhm@1;I_MO8)yT2ksJK8z zFXP>LZk@Fy{fNuOF)xyxauRXxyAs|-UKrz#GX$@`iI_w`+&nVXLuAurXMg()ipJx@ z2;GD6@o-oDru=PNJ2JM&yD2f4@M26ZN}R7OA@;zsh@+JUcOCghI-#_~s$y2}>IbV1 z#q6UZC%Z7m;V$FPtrqS4QrB{S@3LU;#WkZsicT2@^i-?W0aj{m-^@*00pIUNHQ^f3 zTNLX9f&*$N=<_s0^c8K+UZ5g(+f*TAVkmT`yTHRrQyZ>s=&$duuh?*u#;56JzLC0! zilV1II|aATqeJ^IQD~$viELyPv`YJ}URgT+bJ11cNrF8yW!!;`L_+D~%^x~$ubCz7 z>u3|$y1Cl(!~6mK#e{|rv`OE;uW$65op~@b)$Ch%RkJ>x^jBq9W<0aVxufKA-fG3NTxr(#6ygnH{u%tBU2d|B8^Hp>a#df3LDYXXRg z%~35udn}xnNg+5$!|PcoI0Au`{$rwQ$KUch?h@Fp-M0ELmRveMNz)AvmrlDLrU~>K zJM%iNbYEjE6KO;Ajlh$~$bByo@&`3Wj6q=Qx^^(HFT6CCnK1BTipU)+_c22jI$!fb z-p7GNW9zRz@gAE<(7qB#sT%81Duljrn8r5|Y3`o6s!nAhgy^<|<;Ch=X z`nasYi+TcE4K&r=F+=w=cgOV4$Y>w%q@#*y=pn85skI@rMQe{=m-b7o7rt@&bmyoi zvk4oGZlvs{KWg1)^nHrwI0Q9PFPG0C753sNLfiK*xlhY?@HBrw_Jp*G2@0g z=~j_>s)ks&wX^)i{qOZh44$!8%_J-wXuomF3ysgZjUCG&;sRd}~(%6<`yPjsDf*|F05#v=p4 zZQ50Q)nt}7*Hbq0(n8RtR2Bo2eWiVmjmFJ?85K7svGKp+p(?_2e}HWSv1dd(DsDq94`F+)oRz`;}h2)arDqT>9y$>;rG5f zyMf4bV7zR-62Ct^;hgn#Lq0t*k;?ZZ2ifr4r*rjDGI@jNwuBzMo8<9o?_K(7^>t)K z<5z#i+x8DT%bIa7Uq85+q*oHSXeYW5GAX$NI<4Y;H9P73rO%C&p)Sq?Jy+*D{3x}I zlD=l|e8R2jJ1#cvv=hB?ZjQJb=Bh0eJY#d_y@#9IwsGA1`#lZcW3cs+EEyPX--~8^ zvQ$JLsT$~n+eT(CP%Y-Epnd%fe$t8?vPH2C*`JUJCE&F-f291#Ij7eBm<4t+pH>u0?Gvyk1BHHI*<6&UWwK7XMI5` z^Sy3bpyRj^>&ywkUq3Oz-Rj2d$7Cr#yt_LmQ<&T4Fe;z0Q}?I}bEG@AFkGhzUYJiA zQeIDaQpWLR;)ieANfJaAar2BhuXB>rW)E$R_{`N={K6oY^EufVUfb_8C-W6xJ7WiK z&Dith`tYp+*>*DntY&&yxE5QLFWcE$)0Y}3Rqh%LJn>+$qb%@zZ^o_Z&!QZW;&Z#l z(u5n=BxuAULU}9N*o3=)4pUfRW58=FnlgXvmT#;y6-o=wVI9v`_Gm7 z*xn)0Z8|p2^7;0g;A?63xpmoyy+(XS!?dlrHPcH}te*|lsTjw>y-*!KN*+NXVE{K~ zChapM6Q%f}l(P)p%)cg7i><^Y*=In;io1mF7?p0~b4A{AANdX;%DlP{SKLl*pt7oT z?ofTP{uKDW?Msnn$?&V~%B7VU(&#K{YuC>?lKq+YwxXpoTs~?^9jP{NQ7<8#AN%q1 z`)GZOwKL@^%giwYK3S{n3$|*)=e(8m~?UE^kkHy8{A5Ynl zz@0tms&m(U7I3nyZn{m&Th;p%Pc|cWh}Owm8T#wUFfsT(6Uj>3 zp_#-Kk<~?Q!NA$^$x{o7&PBHBcaEFWiQ(?sW>-XgC_B9PDRg`0d1Jd2t^J(3LFI+> z^9c@NlhPa~gWmmC7sc=Tx@G9Qujjm^<8Gvga;>K3HfH9K31s4sd1C0kazg*z+shqx zAV{{}{Disj+cabbl12tW4`P$*+Re5oqIze8p9GjO1%}yC{Adr`c`p{8z3yn5YLMX~ zj58UKvRu`Amzeq^LU?$)EyHd7rmT$}XD*XQpy!J+8KyaUmrGmpZx7_X6TEoxr~kRh ztS}p<2nF8D6W8pIywG?Pp)f9NN#-fZ6Q&_^XIz-a>0@fTg0M6FsAQ5``unS|gjA#) zHlsf1ZLQkc;^qSmet9rFZ?Et)q?Fw0CWkF!NhvzaE~DSwVw~Pd_JB1x<(r4N;RnTQ zt4-cPpN{L&G0Goc56g=;u~9e|=6qmPGP}BTB(#)w;l5AKJ5vF#(co(rtbfkFrTXSX zWhME`t?)@hkN??}(DbidJ?VqZ3g3Ai z+Fgz;cYf7Y&NSnH*5n6Sd^Dr)Su5EuOR@R1CLQLoU#=NNFS1n!qQjbQbqo3~vLUn5 zbZel+LlQ&-X66!&8#-(>Y`|AxpvzZ*^MLKUQ#qFk?AltCI9G)a*ebkD<>K1p`tbV8 zCf7#jWag8C7RO6W_rD?&W!7z3H9ezg-y#syq* zxUA`Q7dhie$@IP5Y0`gRAV2V|)zrt5QyW|l_eUl;T&Ym_ksJ}{^L5Y1v7O?4ZI=r- zo!extKVw#v+F%}OA3xvZU<6Z8dMl+Sejb?&3z!^jg>Ht~AU$|Ad;1&x*e{NO1*Bi?9j49Omux8q~QML7L+x5*+8a1ZL zgj#KeSm&4bX}5wBZOl#`)oeQ6#$_2B`uei)swo?&|AG@AMej5i`ILMq_!`%_Y2%oq zG1*1{T3O!pewmNKMPH^Pnz6O*YZJmdKjd=kCDp2HMs5@e4c$E^7sxU>*qB02kC8lQ zNiDUTA)a2js2WN#fBQ_)-NKzO^#wsOfk9Q9x9>f?!)f-UFwKMcg-Y})s5~MT+DyDA z{uyA(>t_elYt_f+-#Rb3PEtt@#& zbQjw+7>%J->;e=;hT@KXj_4VzO;+`q0eMi(BUsyHOiCaU4iBVu13B)xrBh&w-R03_(Tp3DCfJ4CXl0Ja7g^CYPAss$VnoAl8VLv#RU# zA=Y$Vo@E3FYv;o6-qb#&tBrIs#H}l<%VRP= zSr4efKHq^k!^wo8g@78|Cyh^6t-3}(?=}Lv@rxfo9VbD)=9hb*`nSP!!gDy-A@vAu zSmy{AR|rqLgwk3MEp-#s8V`Nox!JzQDa{VIpM1LMe}Wu*c4mYhh7i+!!uD@&(DOd+ zI?NGtUoSOmRIOIdG(ReC??xAQ2$tBQcx_JkY!8A8m#UC;m-AQdWzICF-qgIc#9cjK z?+#5|m8at>oKBd0)c^zNf;xx=j3N_^q5+EY6l;7@lDlyKLYtp)X9FJQf|adbU$nq& z;o$aB&{>#3h~KBE{Fol)?v?8mpjN115ea#0+4dVeS zsghz&rEZg0?)GGh!ovwo|B$84OQw$hz)~D;4iJx{F;2#B4oc?OYGyR#`?aN__)KF` zD0T*1k)1^skMZ`s60}fwsVyiL?fc=~x`SpYWAv)bTSohE$q-;f7_0TV|*^OJsqaF;n zKeW&MzSsG5v#>Hp_?_9X#Upp*Pn2Q*-bfsPn|f>C9ou?)EfVV0XvbdSI z7|kzr*zva2`-?|RX}07pSL|Vm>+ueMk)s))EX}IB{P_Wq0T9l{ck9nDDeP24F%`Ez z;Mzk3Ze?YY8ey{==?6~aZ29eb*of7H>?&f|QvYVjnE276R>h5KGs*}>A>WTxDL;+w zhOEh}43IP8DnYE$-_dD~m}mG{RdLXHvJ&~2Zv5+j3c;i(pNx-C$+u=^LK7%oVLtkq zjrkQZDQ1mBBd*An{JIANE`ZvK(wf;DaH&s&azVxjs!gMqyrQifav2d22?uWA6JEV1 zLhmpCP4t4b&XsK5QC!ny5mADfC|=+WbuK(2_z5DQ3~TTw%K|`woKlw@6nq zb2zmknNj3+L1SH$R@k=M1W7U4QpWowG$?ZY-IL~4=xDW^v=u5y35wxNLvqEL$sqzg zg`4^-*PLv zM`G)}L(5%%TIhZk|4#AMoMtU9X^3(ST_Q20&}1L_0EUsc=9lu>tHME`tw2i^lH3Uc zCR0VN0t*#R;eSi36@Hmi-|yI2*Gk86V1{V)8Vu1bbhtNN6B8qy3l5)^ z$i2z-x4N@^E1TOpqfycAPsPrhmP*NSA7W;GKYHA$o>|3#lfdnIie41T{U%-8i+HW1 zy!R6oKU{tnaJAmi3OjHf-h+Hy-#3DjP6kk9KNf{gR&z3<$aPQZqArINeV~Lmr7VOp zwL%#_C+_=zwjFX6y7=yxjVl$N+6dD9a%d`$5 z+pke5YL&-H`S=7Zl=%CShc^75m%OI4ThaG6rc(Z7PzwBte(|ZSI3P{N=!T;CveYET7u%t`yU%m^Of zvQ*{VBC6!GV8B*Yo0*WMbY5qM?@kz>krSpzw%%6e6q>>0(Db zIuu#GALKN49#Xen3SihmwV6bb{rR-Zor4=9>R)vOGMI%-{L@aB$cC5B&z&1vA00nQ zJVDQ)pxfGwCs-$doS-Ov>sLT#B~1YIZN3I5zCNSgb24OYVFXgz;lh%Ixo3adGDaiF zG1T9rmY7bOi1KgNmpj^<(aH8%*`BYAASf&b5Fy~Aln%u%c#(K#6(1td6rRQe zGL8_Q#0TF-tzLt%RIK+xC*65RSg-bg8LRi#g7=OA zd%glfW-;|_flU+GX0QlPPTBj|EFB9E`~U4>60PRPp`4kw2Nl^^MqH1}h{|5RDwi8* z@N%UP1VL0iqtZ80+G4P0jBRLM1DeQWjJXu8$Vno*QB|zkVp>SvR9~#4tJWCE4&mD| zE@RIUjlH+W`pUO5`w+di|2zOo@cek8jARgZ*BNdR+nqlv0O&ebJH}PP8TPd-EV0fJ zwky>oN*EC4{@r-uZvm4>hNHxi-o^RS9Jq>4RHOzI47}5Okz^ zIs-^**;;O8&0pnxq#Ea|)0$_<1;WF}t2aD5_s6EjDsSOP9fVr6UlT|72+SBj^}fR4cEc^1J(s_V0dsZY7x3B1 zvqEDdtmLBm`ilUtUFO9Y&UowqVMk%#%vruUO-Kb?=)Q58aS|2lvU66RYSuQwFd4A* z@m{Kp=*i?noC4ltME2sg!Qal`21DsJu{cm|gJ-`5l+QPH>FOLPS4WF{VnD#P;bR?> z4R4HCaWJ@+5gdy*hS-ld=+vLEsB(fa>eQOtABl%X@))|6t)|7Z4XvV7$zEVM!oEiQ z7~B>wQUj{WVc?4udyerhy*b{D0XPn?{lq>&{16O$Ji$?`90?glCwj_6HVlf ze=akG&4Y_hYsS|iI}8A<=B%V)DYLHbfZ$59pKenSiEv)f!Nx zF$38!ybIM1z8OR3d_+4oM`ss~AGV6 zn<=F>q;eV%617_M1YJCt626E+XGxa*N4*0^qTo&d3$HfdwbbLn+BMIB(Hxl+KlLv{hN5!rqbim z{60Ci{MFq4$DQT+z+y%4rYsrf191rd#~9ga%#&+j#o=k9X3ILa)|MNur_~wXUnh1y zJPIt@G#6>^^>2P^As9B7ijR^{WN)%5D4s}tuQmIy z)h^HQ*u}K8&Y(F0A?E;f=0|u_&q@3_5 zVpa70ar)ls82scxNkPvYu9&&tCU`PSczzEqGO^INATeL)S9U~j&?utfqI=`JOnnfdyLlJjob4QxO;$`V1dd!D$k8ChMhUf?_1)Inh`90GSM^TroO?N3 z;taW(UF^lYB9^cD5u`235aBcP8z9Ainr7ojftqaDLUPP-(a1TWGv(D_(D_gJhDD{M zod$p!oq@y&WD%E;3Jl3{@vbDZ(ZCHdIKM1`ywDKq{>KhSynm21fNG2T7WTOH&y zXySTvcqfr@6PCB|{MfA!Kq0T|t;S!w_8iz^!M#!l;EoV~L-s23M~Mr5%=oTC0M5EJ zzdk9nf`8KbEvQ!atfqxe&F-IEG(|>qrRPe6L=k~wp?>8$Z#Mf54?;vwinbG-18NyB zdKLGFeVdwk!Jo`*vSH7Spmf< zgLnu_>vZTB(nnaF!I|-KMW2fb$c6IhEM-qkyA%;ThOU!C^60)5BQ4TYtSi`@dgkkV zGg#d7u$MgtvlOBBrUPyz-=Tb6!~lqEPhpb+nZ>KwaP(2Nc+ zd);xz2NWbE7uZ5CrpD{umQ|yM1h88?&7_H`b=fQ<|?`$F7a!^_N1;3{%d8iksz#BI4I*z9Qsx2mYs;SMcF6&3YsF%uN}lIZY%{Q@rMXGxP+PM(1Es0>1r5Y|L47$i1G2bbP}qu3Ep|q zNre*Yv>8~6h%~|AE}%?aIvy!~ZoU4Nk5xBM29Gx#hoZJKwC1fC=2x| z-&1_Y+SpQDc)jr+h0Mp@mGdYg^Z4mcsmpykhaeuR&?jb+Isla9`2E2rD$-(OhoklH zYc;#u4=PKyZ{l69k@%v`|N2tvZeIRQ-r`X%P8SXeQ0xd)@a6_Lal)p^KM{VlK<+!5RE4#g!mfB(9tkHu<5?rPIv1JzT>uM#o z@1uLg-?v^N&-0vGuDxib--$HoiS`}rmTsTD4rzL|6xb%Na}2zPL(zUweOGyaI0{&5BJuEvytcne`<(Ue3! zc~R!pSCXodx18U@L`lC(({iFl1qqk|zA2EADYAWqgCaoAOnjM?Iu5GgAoMQy zl6&N$Z_Kozas1yIqXRp1!$e$&cjj7l zHF_o#(QNPTEls)O2P1m~%stVY!%j<2=~*%E=%=S!4nBx@aKYoTnFLAYf0=u(hB1CP zh}bjE(Lx?KH*);l9=U7W01ugg`OGiBBWq+vF&wfN-x%|_dF37tbX0||Nlcxff0xCy zth6bc=}iSlbSP;TrzXnsd2014qp7L7;3FhL$wMNQ-v!K~D??*JymP$_Am7Q*iK1bE z4Bu+UtzskSVDV}5Dt?vtC;(1^OkdIOtNA;oF>J_jLqE<9l80nC!O7OcZ;!S3{E2%X zF5_SQ)Oz>+)6u4e5xDn_KDZ{!WX}8+u}cE&gMvM52Q`@R@gzxt8j9lWx97{N(e5%E z@%A$D41W$)Z#$gQNirMztC0szMPfX;W0;vUxxb^+_iDYCoG}6lXbSs;2mo zf-na9)D5aH`&eM)B8~8qaXmFOt0}#F+}FwGoK4tqu2R%ulz^*Q?+@aJ=12P{kMrb) zli$Oi)^(|Ioi)bzH<~`w9%ksP^Eu!+^b4LWTt*8$k<1ZdG8@vlJ*{X-eKM@w@hI=- zXsJf~aFdpZk$qbFQP>BSQ`)$OIG(w`@IpG-tkG-38QF`^zWl*io>}h5UV><|TkwNf z)`v|H(MF2?b|2w#^cQZgwdj++^L^!$zLXCXi(%Z&1RSn#Ct&V_u!0h5Sh4wNN{#x7 zTjvjE7(Gh9om$99V<4@wP`z=RFo879egY+Liez%PB zn&iz-XS?&D=bIVT#vrE%z}y3EapXlY_c?##Ts%t|YP0mCAHu`iLRV9fBr~;y;xC zv%58dTc3BfY22*wxOnex^e>YrYu7qI9HIH&wns z7-!8b_jWxV1(e)iZg!yT9@PI9!AWCq);7nSCi>pb7F$3nb`({QdIiv?dS#^mhK98{Sy1 zI;@^zeHN5obaQk`hta&-{CqNQGY^8Q4X~BNIu#3h)mKAr+-7te#+n%n8c>x*L~MHb zc`QfY8kshLvXb#m-i|H{YKbO&zR})Aln#Qd)rLRcdwwfC(^Guv%!lDBz`Yq#$o%X4 zl}43z{%3DF8mgTI^KoMI;tB8w$y{c66F4=t@4EZlH2eG?^l3-)aHw1Lb`|2YMV6!8 z@V?@w-W!Yjb;aVFTou8!$4$@K+;9Kfv{X)*V2t+VrF?z(_BKjM+=QZWI@axm?(3B_3QaFC*{k>+II1Q%$?TNy2Iq! z!~`GxX8h}|i6eUs=80fSlgeW%!4ZDY9++W3sVUkh8W!l6*yTkU#bBx6(kli;O~NWT z4GZUPGolq!b+Db^X2P-3+W| zIs`^b?0Biw%tSAm?$yC6)H69Ynn9&zNj4<_t>99BYgMi#liDbYRTEIk>tB|0i9pR#{xBrxS zWC^e{uX3NM7ZDU0E|Hige6f$}`xR+avqE?B^H1hdy2WhNUn_YMk*X2Vse#miT}YZb z@xj|yUjQEf>9&z6CfSc?)E#>bF+Y-meyJmHXo@XC#2-HRt$CRB`h4HX|F3_Fr~dvm zL!jnO$u}QW@0mxJAP*{ZSd*vkn_Qcr`3;JYrh1#>1QfC&UbY4Ia*G|i%6R0mt^|Awq9^l^JFsIe zVnK+cQWw2!%3;3OfBp>@6`qE16E&y@jztk`g_75%-(@3By~~ai!YxAD$s677*J_>n z>Tc(Oi(}TjHH&SLD`&gWrP`yPu8_kLh#HwucW5f>7FXvCk^dEsHeSyU_t&!Px$@yNJlOeY)XS7mW z5MAA%b0>V`Pq>-Vi1Rt;wMi(JW|;i496L-q`5{sCl@%93EHhhdU(fnpza;0ol}yuV9*im{>h@5qi=n6{mnl!>lO4dLd10K_ ziz)n8E&+Fcc-6q4NtlDvqlcQ61ZEBuGZ47V^EO|=J*A+_w@fPF!0o+r1{N_qi6?@*Dfq}1MVTVsIXl|xP8E{r8@>L)Q4;1LtPJ=UWwiF`nsrO9+60ZDjmf9*PICafiqmdauMQYW^hjT z+-nTZSDBYomPrPd53No2i9xxQ5^Q_YaL?#f?l25=rg9C=1}Shd^;zuMNQQ8f#gpb% zRz$X!1FwtA{>lzZ%Fvt84>srKoXC~A8~q}xLM@z16iHMqr+d}{krRfWbLdqLW|s$+ z<*PJE1%KF_&1rK;&WDFnlWm?u_zDXB75=Vh)?sxF#n^x!WuZTcnh3h%#426~#DwK& zpkdS_OMxVB-pY&v_!}{ii{E$+JJA{}d?u`3TmaB8F{6ENj^>yT2Qz&pOg~C!p%sG0 zE(SvY{QC_5mg%hq%soGTm(KXEmjB>yyMVE}oM5 z>eFwEw^^Q4_Rnw_i@k{Nc~3edQx{nmgeV~lakC}>+qvFbXY#qfc9lWrythN{FP`92 zct>QCQ z_};@ zZt;B--`I|4bG=T&5Oz^VUJK**%V#4{njZElz8$&zRUSwH@mB9sJMVH!#E*27p4|k@ z=J5**v~MNcy&oR{J44p6bklp&N~v3i&=ETu4jR_r2-`__iL^W~%6>JUMQ`N=g3G?* z$02b4|H5p1zd=T?WRDmhtnIA#Me>y~xx&4yrO8HFBeU{Rp5Opm<}T_yx`lZN_(Ih%8jL{y29S zcU`Iy016npt+RzB7tTUu0%ReOGb!AYW7`@Y!_th%q$>wdHwk~1RFu(+)VPGvnIE^Z z?T&kL>p-4~8 zay+qen)g=XVLV-q2|-8=NmxR%e6)yc>YLsepX(a6M3VBno>wZAV{yVLAP8fM{bX39 z%ctus$BIQ&kjWF`P)ng3!GdaUKW9#%Lr3BQP-mG8BvYWrB_~6^Ciqdpob3Pztp^WGa!r6s$2(DC_VHTl_{HraFF?V zyC6kuL^fPcFp7*jg!df9Lzs}*?S~m1dRZM^PdOH2FP#;2>{jVQ-`LuLC3=NjX>OC_kyF(GV5 zXC6rk{hECrUkbq>V}X`dHeh(?!w+g-Csrcwd;JGpz)GjGzpB%p(sbzd*WyA&!0+u- z^otqo>VQ!Gk6Pu5-~KP&&?T?CDSMJzKzJ@y5gv^ARx@Wm-fW@$=Jnk$V4 zEweo}&n{VIX13a2;jjdf%wFFZ@^3(zJP7^LO-SAS?d{v4xuaTRdUdfI{ogmd|Gfg? zzGe9^Vs8U2=UtQqZaus%i%8^0A<#HEbp5?@IJ0vC5Nql8&O2}rvS#b` z+W>9SBz6mNvLs+_Ge)HPz~i=p4CD4IMz6zO1+}KD9tH7NNUHF3(6s~pOky|_Rf2D8 zW8aN$h}Ob8wiD<`<3QLz8Kbum$)&3@$_6sf;`qVz2AFmtK`?R-5FAjMiB`k2PRaF= zBkz-HOYC|!YnzLqkWmFWYQMs{7=^&`dxshMb?Ij&VZH*Dm>2?M^n^$4d^dj*%mD+g zg*BlZmD=COSueGVs9_Z&nc;T~`fy$2n(c+LrL`-Gy^5>O=AUw`4;Q+SAe zz_}C!W!EZg&KRHTjaWl;=yakRG>5JR5VPK)cvE!5tqwRiMX=vRKWGx%f=Yu=^+tA6 z?j=7(Y6X08U@L>UmHfnzdk@==zA7fvH%@qoQw1pwTn}Ejzi}Sd8sGT4He5hT&C;m? z+%a+dSkta$SLuKfl6iIUdE}nw$+XSgao+o^UPX}QUE$Ng^5Jp)n4;k~uM5AVnuU9I zHyMvw$)V0*$#_evOqw-szK#`WKT-jQ}A=v?2c<`*Qwv7ps&OwPIMO0|UPgEkcIJb}> zi-et8XaVC=lDg!D;iKTy4XpQiOvoVrRoleGnW;savLgfCCp#*N4u6O6LKL6ZR5qO` zWF7b;VxJ;)=;c9dsZ=XW{cll#SSt=|diL=6-jSwRD?$Xh&mhh;>$ASW=-0{N*<&(< z30V=tK@yL%a-f2C&>X^84G*ai-fs_ZTENZrI|kmo=cD-^%;uSZ@1&z zKA1tCXrysHx`)@D-;6iX*V5PYMpQ*V=C@6(M4{xi1=9@z{7*uGi2De&GJ-teY7LUk zNV9!iE&3f6VtA_150NP>XJ6;FiD;0@cVm+wr%yKBlisWKIzd6fY36)wfLH6|#4g&8 zJC3hhd%j1PG)hCyEA?qAmQOM=-Bv$*T%NE{boh=@K1_aFD8(3r7#@7?Ti?ZKVLtRU z_|*H+HMc9a7m~gJ+weSqO&uP)$PZB_Si}VD%jvr_CK_M27r7?*6_9H>`z&9b%DsOx zGAmszZ`Z82`H=0YdBEv|qsDbk1ja5NiqiHm?mb&Omeo3q zsf$Ekxor@!>`}uROGZs>U>opl$D&jHMvYwzRq#wXroG=#?A1fVHecoJ)Y^V*$+mUr zy2+0Dj+e8r2f~jI8Va%H_=(K3RID(>=P4{?d*@3*E0e(t$s1HF7lkJLx&* zk+}m$xnYL5X(G}TCS&cACdV;Ks9xJ9O{UbG*%TSLJ;z6|>U-0`w?>J=4g=QORgcj4S1`TAwl#JKLu zXb&imQ{Ild0pFTiT3n+0vZ-FBE(o@Qk8v4i;`IbP9ZtAqPz8QH2p#1)mGC)QQFB3! zhFId|nS@CuK}6SWq~Cl_7H;5c2yExy?*3y{w#t7(r106pIjMij^9szOYvcOSxBQnz z`k`K+iN#}vb>;umExwXu@hLFG%(o^*nOjn)x|FO6Jz4NaOM&hxGbD)eNI>dm7(L|` zv_F6oBq<=0F%9k9jGt$xil4vR3uUK5pru;lIGA95_z{R2Z9a^5e1c1PNa}_K4(Q1^o-AZ|{_#u9=R;Pw3 z^iZ2()~xS%gkv;%wwr~dn}viGkyJ{F+Nb0uM)_Q%f})hwJ6Pr`*64U;S(9ysd9b z&6}Q`>R^29kTkiVw9!f&JH@>?9J{26=K-lKNum877AUZKVF;Jl|4SDL36CnB$++H6 zr54|M%(g!uM8woZaUB97nl@(v52fU}m|PIB8q~skuVIX*`f4wu;)R`JDaAX`|z@Hi{*-<7wOf65!fe4G=;O1;rgIXK5>$ zk{fr)!8B)Udf|{9!CrG$Dt|Ox7TvAOF-%}$>hjQq%q2d`Rt7gsbX&ijmhT5@0unH? zb$}M(0Lxa=XOX#*`RCsOHG|VovN$}LwN0K6hbg!S=NPl&#wis3Lk6m5>I*r4tUv9; zT(;wUYxDYYjwW|lkOq|tno3i!;T97wU4Tc);bSSDfk#nwQT$P-?1DAIIE~B+H7dd} z{=5?#J;xWRljq3w#Gfu8t%B!EGE{(n8RDyj(c>$Q_05hOXds&|w}ANfI!-p{MsaBLk+16xVj zeqm$RU0B`EwOCv!9$I#+{(jhYnRw#0{8seqNA<XBRC>J$4-CK-6$QC; zxUlR@uj9v0p#iA#^6V(&zF(|#>;D2ew3zClzt^|?=`9YWfvg@L%7v^B(T4(TX6h8i z8LU~Cm2@Z>a`tPsfTd`ZTi@0EVMDzm)yMY=M_$;(#e9+3_vZ(9e%vZXMG6_6>)+|h z57*uHfQKh+w4OD-(RXf4{S3<71IC}9g!>;JY&jW8JA0io1?E04+^k&y;f6rfHKtzY zmt`8#pS9W$zuZE3VQj6xQ_9mszTC?C-1KdVU%+!2Fg5B??dQ{|9E8*hc&Unc)iybM zbqUI(WU?x4Ov4{h`j~*SjA>FukarN=_I|WhE3ha6wzpdYDE~dq=4k?|3 zXWhx?vC$2UX;c_s-SdtqTO0i|p@r;@palktocH)e6X_BA)iD3!u+K&j8~_W!MfKNXiC$BEfdXv z49JOME66GSb}A};jT*fZ#vW+i8g(Orecon}6GjvFuxoD~byCI}wU~kDR-_~5&w`2a z;V}faGllc`%iv~5usq58M`~M40mUQU38ZWg%fs=M@w2<$XkXT1r;lCSH0AoCQj1KK z#9Y2KgQD1=wAVURR;|1it8*8x3DC0h#xp#cGZR?%fXtq9l6jefzQN<@#ax>bVZpkOA z7>fxEGGGU;qPX8o#eeKx{Iep*v`DZK2R`bvB&F#bKmgeCx8Zm+3pvQ$&8`3qnvcQvqNZG*7rz`U17r`Y~_KW={;*ICufeWV%35K#`l` zm{%snI(-VekGttHjwBlhKT#K-6P@|!HB}C34;MA)?O!K*p=84NFGbH3eugBci2_f< zpoj;dpvTaDA|NMv?lpFU)aV#fpgqnX3z&Ej689$^0@C+*CLHosp?PEsIG#`8-4>8P zr%P0h-Yd*g-z!`K|08IoylYkl3vz-UsXOl#>{qqzWs@beqPjY{|1}>0cK?Np34pR5 zvnAbiGbhX?1=sX>d()QiW9pJ{iR95pTd*Gq_7Wu`*8)6SA;Wq#(_D~E7uR~4qXH1F zr4r%gOjMyO5j0JS!)21js*pl0k69$cKT=R~y!_`(!LHK1+Ng{>?W*=#Oh5D7BJCfJKNr3Y zbNz=Vo>*2Evewxca%y7EBywuEY;lnxojtIaQmtpm)G@kj)gpzgzdwxs=ZXvev`eGR_alWx|FEElSZ2iysY+`v~698Vy$AFR$y4cIZGI25ce8k z;HVmDtpy&|o{a!h0JPX9CRVEE~vS0xrZRnbSLOd zl3~#oJFk25_yN>|Q)Ow{>xo>>-8}mJAQ1{LqyKdvMip8^KHPRqe(0!~6k0k>eYlmB zQrgZ1yZfcBsJ^iP@OP@xZ9bP@R>~Plv$Y*ldQzFT$gg2I-EhVgEY(2QU4shh&(=p4q z@DA}k(Y2D^A-v&@XTSQ zp$+me%(H|AL0Yu*(9w%O%aQg^ma5n*T#}oELH=d*7bw!xKe~5hNGx&$t=b*#J;|2@ zzj55ALjU=vaz8qm*ZB`gsmE|-2iy;@) zK>ICc;CDMcC;K*RNfLHD7XklJ^}0~B1wmU9Zl&t3a-bFYz=oMmkSnM{`x!*StYi!t z++IJINO;#M2=x0VPCiM<-gPwCr3<2ejpxFrXO*kK-hPIYBrQ!3#66{>u!wEnubq z9wD)Mq|RkG_^i2tn7#5>qrNc&8rk_>!4WK2DfCmKgn@%I6p*=t)Nm1LIn?M3Y}Np~ zbEr#X+<9Z{Fh;m*RwVKmf?q^$InM-=LmM#runnp<^!O>kB505Cn)8r5yjQ`N$0XgG zAhY;x>`m5%g{{r_)BL_tRzic(8(byb|3+ub|6vP`?V?$tYy|}Ym6ae^2c-3sjixD> zvSE%spT;W!3>r8vz7(l%a9;bd?qEs)EYXRmV z%aorBUfE;(xyJ;)Qxl;h_}raL)4}Nl6}yK38w9nV-$Sggl{>x!4l-u2!o8rhu5zBe(bK(LYguflF!j7o>zq;^l= zgNRKsUB`{Ak@vc7WL|229bcJEU^8yCO-o>LM zxH0s3h~BBAenqfW{lBbY7waH!`?owc7o!@`-M~<$Buq`U3rMS0_~T``{V!zC^#*kU zWppYNH$t!cC7^o&y)Mf(NBMANA%<&>QRm^PutCB-2hBD3j@$G_2XnaQ{hMafVVF>_ zAF_i2QhOLlQe-wp%qaq_;@Qn-tuZ1~|ElY0i7X_pLD=^LF1gfvxgdZE2n=ED3L8Xq z)E)|_=r+((l->rQG-GPdSIAJ!tl;v!Y)PZ!a3wIJpQC1GqQN2k0q9cpAF?SW0YI(lVB!rHgz^dcM#;O$$^2|7xiLBANK&IUzphW z{-VN*xg>piry^GnIstCxdRFJapdG^m2JN$6@7_buiWyNx?e?_4xqb-`#8^>KQ)lEr z0AG9vyL$&9z>eua(qoM!`$_$?Zx`JjNj1iiB!kB8NmLju{Y7y^pL;u~x3{s~dn#uM z3SeJe6x_A%?;LPUWVlATV^c|hU4D14c(_$J?X5Ey0m zcP2(LRa9n1frjM(DrgzdSB~58+u>rKoEMHjx%>Jv{|PkX>Dlr(RMDHakN^%>yfnCu}B4Gtab-b$@`ogX&w z$>NRVnQS-`Y+v`5$vNZL)6oRRxbP4VKf>}I zI0jyqGH7NW0+xp1(&4sso>v4$)&HLrfl=oB~Yc+Zbgb9-e>fg`D4m%b$Z1n$nNH@4pirJ(aK^(ci~y3opZlEI5WG~ zucXz+)qET1MSOs+SyfjyM;LeT{}A>L(3v#d8fZA-#FL55iEZ1qZQHi(Ow5UG+qP|E zl1Xyk%=i80oPXVQ*Ij#c_q(dAtE>9mwX1tq?dNf_pMy-axNbc^czJ}@2PSc>(1Z|N znnyTLZ~0Q`cUG%%HfZ|C+xtX4rB~9?%dWZp>^AOBr}A`2CWFnQ^i*X1#V?ZrcV>Gi zKP5}<<^v;tH)2Y7<8j4*+yTNK3nB(0isBM zT-lGk}@&( zQs=#nNVVymVQa}-^LeRsJS)$a!mvHNP3-7PVHX2`IWoD-YSJiXV<}8RtteB2?%7D@ zL-)UN2E*_ToT2UkofH(u;f*IC@Z|jllm?NcOdfv!XIgX6p;7qCLs5 zP_9hzl_RB@gYlDnd>F`W=t>ruboA>6jPw{Ak^71)27~555O(!ph0vR5km~2Ed<^aO z^2GLP9l|1bWr4H_Nwc9V%SVz#=ejP(Tsl-C%uCw1>;WCK_Fn6&X^Uz#+x4P(Cm*h z?TFd}T6(fUdtP0YhNK&bo?_uKmEln+CY7 zn-KsGa>h#}8PW!_A~)VSKXV91?8g$LB7=OhG_%?I@z0_q+zR-=iOu;*r!Zop zNsdV>6d9zLvB9&&Y}*FVXQ6H~m|&zv%X9diREvBCeDdC@$AJQ%Dyr)fAtYOjFi|I z5(xmr5Idt2Kqv2X^*+nm&7bRX=&Q|j-NFoavFlXE<)1yd7PLFzE!I%H|0lrnCzbZg z7GQaL@moeRQbx7q=EI2gI`4Ag8N&n5E9#Vp431*smyR2=uG@XP|6nYI%byJ3$|gGw z_#_ewE|9$EQ_7h`j3QkpesvX8lSL(g8Kh@1(5n?pWTQ>4*To(5uMsT8Mw94P7*qve zKqWkJqpTTYiUBtWvl`c@H0$Ax1pJiepiTBIj;zt8REx@68uG8+XDw62h3S>|C!^{0 zuO@mqJ~e<6QLQJjFc2&DH8s!!su#mauly8@lL0}JG2k+jED-11Z%6lLW7_x|2IK+ zm=GcO2prT%;@rF_K(){!P*Ed|9vW2PC2R-tLWGDU;b9_z2K=iFc5qjnagQCtki%;vr`?n0SK?NHu)mC8Vr@f(Z!f>D3*9 z1t7bKokk}@8dM9CV?T>`D=gaMrc_#P@?9+djWMte?$H-b9f)Hn8ywI3HztizNj{L6 zd_Dwl2RU(wUcmqK`AEK<_vnT>F9%~_nq##YZ&QdZSbBo%gvqmCCjtJ4s{R9t4#)NYxE15cq&XB3MHCQyJt32}_rKlF zTyLu)K7OA#03)7e?Mj_*p_?Xhfi@JZzYF=%_?}VmMxl%D}g> zW5ESC^xSAV?U&owcZ6zoDjx1>)4jO<`Tsz2Y5nkm9>C3sA(NrGN9=U=bRy-)ofaXV z84||3=X()F^Ni&NS%BUqEENCh83>GvX;%=lZ{3GGh?59E3UM8mWewq3pjhSyznves z9dO;_gzwpnLyvn?GbDUHK6GG3ejBI3h40zVVI2owDKV_i_bghf2#PBw`Q1&Scj&a7 zQrGYAXAJ>;hY`h5yK&^}&dSkPV#z^b z(Sp%L`*UMsP&ypG>96sMzUlQgYEf*oQDH>EH5h~GvV|n``_X2uGWIlKc%tlIvq*?O z{LBD#Of3>*|0*d^r1rZIXg2gV{C3mocoy3Euz>S;^th2$PMd1{K2h-pBv(+jyf7E| zGY~fc=V7-;uyvNEo7YITR?k+dUWFur(?i) z#B%Y%8yG}I5qp?A)DWvK6Uy`*IA=D!F0iz0lDYhz-EH0HH(OMMFB55%p&24}KiO^u zQ{>v0G~!a$Zo`Kk2EE;GA`0OAH5$fI5g8*O1=TGAu*F{hW0h|Dbgdo+vZ@{iz0~kj zxV7#^H!Oj|^e`jd*FCXA;)Z!3QGvqTSy{6Z#?qt{-yczwQIt~sG0<^`n?mWIc9#ql zu#y7j@k*0EQtG#}{M$h3rjzWOaWfU$42>G{+C6p3N!%iz3BK6ys4 z0KGnARNv1zOHzTmizR#<7SrKd0v=^?%pz#r42`Nxz^sPTOsFKJ7uaTZKL7%}42~y~ ztO@I$N&Yk$WwPy%KTxM8lD+||WWcJiZ~L{%oi{43z*~5mU2iDD7W@1e;4eN4Z3wWthv)Ka&TyXKc>IN(YtK>aX#Ns;y03^L0R z0fkDCYmR9IEShmnIa=f*fL2m*e}@+P8U`6OU7=^u5ovf<@-5wx%EroNe4Nt!MywrO zXkpY<$%~|6zbsY~W*uwt_mae-N&U0W!|878p9Iw3yk}(7tF9JyXZxoif})V7RMu2T z1V|tn5rJT>n0gk=t&s}+%%D=+5@{KIi}=+I^`FADqQ1&Lxd5piuxJ#x*t;0(gfYdi zpiUt8Da-6kLN#PHwSUD}BLzwA=eMm+pZ3+0Mf}MZ_w|=kfF>1J zc%L;pFmmmU=;6dfBw$H(npXVxO0Sjc|Nel!`T1e-OGlGQb2<Pl`FSb%9OOe z?_B?==QKWe5+Qb@8YNXrq&Qj{JIn77Saau_a^^~C zr-tX&`}Wj3?AO!XB&0K$Y9>qU8uq@$9vBEqFCI)Gy|d=!7aFn`m92gD>t@f={$bF1 zxJ6g;!LJ$-b`f@S6?>Xdjuy-84EWywI$P(SJ+f$MAs_|Igs)Mo)Fi~;JG^M@nejap z>pB4v(3L*V)-tW6TVfxX2Uh5vwbMfz+w}nw%`D8$LQ;?gq1Bb&7}?=Fvs6az^jrT~ zUMA#zu{0zkX4S-DVzTkHq3v?7w#r^`Kx~x-hk&nbkZDIeOs#I`-_;bl^v7li2p?zeL$bO(UN6ntr)izyyH%H8^rm3=s= z$=*zFzghgh&`5`5nE&saG6fs~K;l!6!PEp6Nv^~Krhnz5nx-=uQvE#vq89O)GQ{^Q zBJPWrz)Nf$iQ3p-Ns+7Nrs(wgaBWbi5XgLZ;2i$%asN;Ef5Sj{^*z|U{|~{>^Ay>y zQC#S>_3R$Y#%LX$@+9-ae*skQ?!)-)Ui8x z>Y4ujaH-ZY$G&>?#O>qO_ks&?v3UQ6?(BW#&Cat`Mcust<$VGx^7Cg?H0j3+fw|@t z%9Y;7q;HWciuGp5zqT4_Of@@OdMEg^Uu(@7)%O;h(1RIwVXutOV>m}#t>OMz`8lKF z`8k{IJ9c4!C<{OA?PjPE@IJ&J{R7Skpm+nI^V$8|ZC7m_mnA@ZcpSs;7exM5s!Nf1 zHw)#&)L3{NX<6gcXvj^}e4o9WjvNoLDLNa-?`lRVI{)BE(n`iQl-XP(sU70+Zb2jP z=wHSEj@)j`drpkB@>Pj^vD%^(PCl2NBnGL zL38rC%KjL0KXRl!o#zzT>~_Sf$-A4BNJd+C)8^9T1UjSHSbuNdm7=khC-J*k#=rOlv`5v(^i zH|kFsggUqDQ`f_SwfHK19W#d21RZa0cdPHuKR3KRszXhSr|n48ThgoaM% zM+3`2j_b`vxq1H0xe?PC$a4U~(?&=>4=L0Bc7YS~(wd!wcJBDpTR1Yzho^m#>hhoB zeh>h_8lTGDI_k6%$Q6QP5>9KY14ey+Foms9>u88fY~`pZf?qjS&w?<)tdhM7_W^YC z54R~w9famx7!Vb2jU7|{TfefzIS@)hNDuv91Q6$g&1q zAI_A(WtLek6pNc`x@g|UAh#Xd_O=Caq>!lXEDTX0chhtH6B`!dC-?U*0N#{mGhm~$j)WT= zFyh64hPpH@=K`?fZ%f_^8Sf4k8d_fRon<}=PkXNJ5YnCc7Z>UV%hUv;@ZmiFKuU{X z{&jcEQQjpC0oRTX;I3EI;95Lca4!tKrO&>#*4(}_v1N5Xgm)GNVQ5tub!xK&%r5Oi zf5dE6E|;Gru}fkX!I7%&X;sZssqBAqJLtI8PTB6TCfe>OlFU)9+ObjDUwAlmcj{=> z)~bq^8a_L{Av{XD8+8-XM#is-R9R=jcN)Anb#`iN)!L{mR66)wNxii0u1yLva%khm zwEt+s*shKBVE>}E7o{%2#`!0o0_4!mrt%{d-DZkKXBWGc5O4EnpuQn;AY>v+^)=

-EryCf5v#dc)Qa%P-sKy|#J7=Lf!iTg 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 CfEN@1 literal 59823 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%0D;N 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

K-MLkdyyxq*Et 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�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�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%0DYOvL(HHP$@)nQ1m@Uc&s+6{gD=#t2k=kJ4SAwp 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�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

VNuvqM+s05}ZRCpr8>9$Nb-+ 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%0A%=h=5E{#3+;2%r`)_q&$lA0W?LNA3PTLamBF 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ངj{!lO|l> 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

m_5wswsi*r}PYRRN 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

TSQn!6fHb@XgDegUc?UzEOn>P}Ue+ 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ûUE+qjNSxF38j>w`k^s$w5rrSl=Z_(zPXp;l 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
  • +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%0Dx0(kqlw9>&&X?2KSQthyliAmxRq zFVSG3Q`stFR~ZQod?h9>Zz(`<{A&x5nKljQ42l$@L)T5$?fleU)({~f!ZCyT<>mMA z?*rSC@?MrnAMX@&bx%q5J$GOB8(;2w2A>$3n1?})-SH3iaQFG`b4Q1kwl>o(%XO=4IsM diff --git a/generator.json b/generator.json index a8acf4a210..ca46902c56 100644 --- a/generator.json +++ b/generator.json @@ -1155,6 +1155,7 @@ "-Ibuild/include" ], "traverse": [ + "$windowsSdkDir/Include/$windowsSdkVersion/shared/wtypes.h", "$windowsSdkDir/Include/$windowsSdkVersion/shared/rpcdcep.h", "$windowsSdkDir/Include/$windowsSdkVersion/shared/WTypesbase.h", "$windowsSdkDir/Include/$windowsSdkVersion/shared/evntrace.h", @@ -1165,6 +1166,10 @@ "$windowsSdkDir/Include/$windowsSdkVersion/um/fileapi.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/objidlbase.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/objidl.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/ocidl.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/oaidl.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/propidlbase.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/propidl.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/Documenttarget.h", "$windowsSdkDir/Include/$windowsSdkVersion/shared/evntprov.h" ], @@ -1177,7 +1182,104 @@ "_STGMEDIUM_UNION", "_GDI_OBJECT", "__MIDL_IAdviseSink_0002", - "__MIDL_IAdviseSink_0003" + "__MIDL_IAdviseSink_0003", + "__MIDL_IOleAutomationTypes_0001", + "__MIDL___MIDL_itf_d3d11_0000_0034_0001", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0003", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0004", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0005", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0006", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0007", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0008", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0009", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0010", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0011", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0012", + "__MIDL___MIDL_itf_dxva2api_0000_0000_0013", + "__MIDL___MIDL_itf_dxva2api_0000_0006_0001", + "IClassFactory2", + "IViewObjectEx", + "IOleInPlaceSiteEx", + "IOleInPlaceSiteWindowless", + "IPicture", + "IPicture2", + "IPictureDisp", + "IFont", + "IFontDisp", + "IFontEventsDisp", + "ISimpleFrameSite", + "IPersistPropertyBag", + "IPersistPropertyBag2", + "IPropertyPage", + "IPropertyPage2", + "IPropertyPageSite", + "IQuickActivate", + "IPointerInactive", + "IOleControl", + "IOleControlSite", + "IOleInPlaceObjectWindowless", + "tagVARIANT", + "tagVARIANTUnion", + "tagVARIANTUnionUnion", + "tagVARIANTUnionUnionUnion", + "tagVARIANTUnionUnionUnionUnion", + "tagSAFEARRAY", + "tagSAFEARRAYBOUND", + "tagQACONTAINER", + "tagQACONTAINERFLAGS", + "tagPROPPAGEINFO", + "tagDISPPARAMS", + "_wireBRECORD", + "_wireSAFEARRAY", + "_wireSAFEARRAY_UNION", + "_wireSAFEARR_BRECORD", + "_wireSAFEARR_BSTR", + "_wireSAFEARR_DISPATCH", + "_wireSAFEARR_HAVEIID", + "_wireSAFEARR_UNKNOWN", + "_wireSAFEARR_VARIANT", + "_wireVARIANT", + "_wireVARIANTUnion", + "_userBITMAP", + "_userCLIPFORMAT", + "_userHBITMAP", + "_userHENHMETAFILE", + "_userHGLOBAL", + "_userHMETAFILE", + "_userHMETAFILEPICT", + "_userHPALETTE", + "tagCSPLATFORM", + "tagCY", + "tagCYUnion", + "tagDEC", + "tagDECUnion1", + "tagDECUnion1Union", + "tagDECUnion2", + "tagDECUnion2Union", + "tagPOINTF", + "tagQUERYCONTEXT", + "tagRemBRUSH", + "tagRemHBITMAP", + "tagRemHENHMETAFILE", + "tagRemHGLOBAL", + "tagRemHMETAFILEPICT", + "tagRemHPALETTE", + "tagpropertykey", + "tagEXCEPINFO", + "_RemotableHandle", + "_remoteMETAFILEPICT", + "_GDI_NONREMOTE", + "__MIDL_IWinTypes_0001", + "__MIDL_IWinTypes_0002", + "__MIDL_IWinTypes_0003", + "__MIDL_IWinTypes_0004", + "__MIDL_IWinTypes_0005", + "__MIDL_IWinTypes_0006", + "__MIDL_IWinTypes_0007", + "__MIDL_IWinTypes_0008", + "__MIDL_IWinTypes_0009", + "__MIDL___MIDL_itf_wtypes_0000_0001_0001", + "__MIDL___MIDL_itf_wtypes_0000_0001_0005" ], "rename": { "ETW_COMPRESSION_RESUMPTION_MODE": "EtwCompressionResumptionMode", @@ -1228,7 +1330,103 @@ "tagRemSTGMEDIUM": "RemSTGMEDIUM", "tagSTATDATA": "STATDATA", "tagSTGMEDIUM": "STGMEDIUM", - "tagStorageLayout": "StorageLayout" + "tagStorageLayout": "StorageLayout", + "tagPROPBAG2": "PropBag2", + "tagCABOOL": "CABool", + "tagCABSTR": "CABSTR", + "tagCABSTRBLOB": "CABSTRBlob", + "tagCAC": "CAC", + "tagCACLIPDATA": "CAClipData", + "tagCACLSID": "CACLSID", + "tagCACY": "CACY", + "tagCADATE": "CADate", + "tagCADBL": "CADBL", + "tagCAFILETIME": "CAFileTime", + "tagCAFLT": "CAFLT", + "tagCAH": "CAH", + "tagCAI": "CAI", + "tagCAL": "CAL", + "tagCALPSTR": "CALPSTR", + "tagCALPWSTR": "CALPWSTR", + "tagCAPROPVARIANT": "CAPropVariant", + "tagCASCODE": "CASCode", + "tagCAUB": "CAUB", + "tagCAUH": "CAUH", + "tagCAUI": "CAUI", + "tagCAUL": "CAUL", + "tagPROPVARIANT": "PropVariant", + "tagPROPVARIANTUnion": "PropVariantUnion", + "tagPROPVARIANTUnionUnion": "PropVariantUnionUnion", + "tagPROPVARIANTUnionUnionUnion": "PropVariantUnionUnionUnion", + "tagSERIALIZEDPROPERTYVALUE": "SerializedPropertyValue", + "tagSTATPROPSETSTG": "STATPROPSETSTG", + "tagSTATPROPSTG": "STATPROPSTG", + "tagVersionedStream": "VersionedStream", + "tagAspectInfo": "AspectInfo", + "tagCADWORD": "CADWORD", + "tagCALPOLESTR": "CALPOLESTR", + "tagCAUUID": "CAUUID", + "tagCONNECTDATA": "ConnectData", + "tagCONTROLINFO": "ControlInfo", + "tagExtentInfo": "ExtentInfo", + "tagLICINFO": "LICInfo", + "tagACTIVATEFLAGS": "ActivateFlags", + "tagAspectInfoFlag": "AspectInfoFlag", + "tagCTRLINFO": "CTRLInfo", + "tagDVASPECT2": "DVASPECT2", + "tagExtentMode": "ExtentMode", + "tagGUIDKIND": "GuidKind", + "tagHITRESULT": "HitResult", + "tagOLEDCFLAGS": "OLEDCFlags", + "tagPOINTERINACTIVE": "PointerInactive", + "tagPROPPAGESTATUS": "PropPageStatus", + "tagPictureAttributes": "PictureAttributes", + "tagQACONTAINERFLAGS": "QAContainerFlags", + "tagREADYSTATE": "ReadyState", + "tagUASFLAGS": "UASFlags", + "tagVIEWSTATUS": "ViewStatus", + "tagXFORMCOORDS": "XFormCoords", + "tagPROPBAG2_TYPE": "PropBag2Type", + "tagPROPSPEC": "PropSpec", + "tagARRAYDESC": "ArrayDesc", + "tagBINDPTR": "BindPtr", + "tagCLEANLOCALSTORAGE": "CleanLocalStorage", + "tagCUSTDATA": "CustomData", + "tagCUSTDATAITEM": "CustomDataItem", + "tagELEMDESC": "ElemDesc", + "tagELEMDESCUnion": "ElemDescUnion", + "tagFUNCDESC": "FuncDesc", + "tagIDLDESC": "IdlDesc", + "tagPARAMDESC": "ParamDesc", + "tagPARAMDESCEX": "ParamDescEx", + "tagTLIBATTR": "TLibAttr", + "tagTYPEATTR": "TypeAttr", + "tagTYPEDESC": "TypeDesc", + "tagTYPEDESCUnion": "TypeDescUnion", + "tagVARDESC": "VarDesc", + "tagVARDESCUnion": "VarDescUnion", + "tagCALLCONV": "CallConv", + "tagCHANGEKIND": "ChangeKind", + "tagDESCKIND": "DescKind", + "tagDVASPECT": "DVASPECT", + "tagFUNCFLAGS": "FuncFlags", + "tagFUNCKIND": "FuncKind", + "tagINVOKEKIND": "InvokeKind", + "tagLIBFLAGS": "LibFlags", + "tagSF_TYPE": "SFType", + "tagSTATFLAG": "StatFlag", + "tagSTGC": "STGC", + "tagSTGMOVE": "STGMove", + "tagSYSKIND": "SysKind", + "tagTYPEFLAGS": "TypeFlags", + "tagTYPEKIND": "TypeKind", + "tagTYSPEC": "TypeSpec", + "tagVARFLAGS": "VarFlags", + "tagVARKIND": "VarKind", + "tagQACONTROL": "QAControl", + "tagBSTRBLOB": "BSTRBlob", + "tagCLIPDATA": "ClipData", + "__MIDL___MIDL_itf_documenttarget_0000_0002_0001": "MIDLMIDLItfDocumentTarget000000020001" }, "bakery": { "profileNames": [ @@ -1253,9 +1451,8 @@ "_EXCEPTION_RECORD": "ExceptionRecord", "_FILE_SEGMENT_ELEMENT": "FileSegmentElement", "_RPC_MESSAGE": "RPCMessage", - "IDispatch": "Silk.NET.Core.Native.IUnknown", - "IRecordInfo": "Silk.NET.Core.Native.IUnknown", - "ITypeInfo": "Silk.NET.Core.Native.IUnknown", + "IQuickActivate": "Silk.NET.Core.Native.IUnknown", + "IClassFactory2": "Silk.NET.Core.Native.IUnknown", "tagEXCEPINFO": "ExceptionInfo", "tagVARIANT": "Variant", "tagDISPPARAMS": "DispatchParams", @@ -1263,9 +1460,15 @@ "tagCY": "CY", "tagDEC": "TagDecimal", "tagSAFEARRAYBOUND": "SafeArrayBound", + "tagQACONTAINER": "void", "PfnTagEXCEPINFOvI": "PfnExceptionInfovI", - "HICON__": "void", + "tagPOINTF": "Silk.NET.Maths.Vector2", + "HPALETTE__": "void", "HBITMAP__": "void", + "HICON__": "void", + "HFONT__": "void", + "HRGN__": "void", + "HACCEL__": "void", "HTASK__": "void" }, { @@ -1817,13 +2020,13 @@ "ISequentialStream": "Silk.NET.Core.Win32Extras.ISequentialStream", "IPersist": "Silk.NET.Core.Win32Extras.IPersist", "IPersistStream": "Silk.NET.Core.Win32Extras.IPersistStream", - "IPropertyBag2": "Silk.NET.Core.Native.IUnknown", + "IPropertyBag2": "Silk.NET.Core.Win32Extras.IPropertyBag2", "IEnumUnknown": "Silk.NET.Core.Win32Extras.IEnumUnknown", "IEnumString": "Silk.NET.Core.Win32Extras.IEnumString", "tagSAFEARRAY": "Silk.NET.Core.Win32Extras.SafeArray", "tagSTATSTG": "Silk.NET.Core.Win32Extras.STATSTG", - "tagPROPVARIANT": "void", - "tagPROPBAG2": "void", + "tagPROPVARIANT": "Silk.NET.Core.Win32Extras.PropVariant", + "tagPROPBAG2": "Silk.NET.Core.Win32Extras.PropBag2", "HPALETTE__": "void", "HBITMAP__": "void", "HICON__": "void", diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/ActivateFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ActivateFlags.gen.cs new file mode 100644 index 0000000000..5085c384d3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ActivateFlags.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagACTIVATEFLAGS")] + public enum ActivateFlags : int + { + [NativeName("Name", "ACTIVATE_WINDOWLESS")] + ActivateWindowless = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/AspectInfoFlag.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/AspectInfoFlag.gen.cs new file mode 100644 index 0000000000..86a4f24cd9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/AspectInfoFlag.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagAspectInfoFlag")] + public enum AspectInfoFlag : int + { + [NativeName("Name", "DVASPECTINFOFLAG_CANOPTIMIZE")] + DvaspectinfoflagCanoptimize = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/CTRLInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/CTRLInfo.gen.cs new file mode 100644 index 0000000000..bd96028dc7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/CTRLInfo.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCTRLINFO")] + public enum CTRLInfo : int + { + [Obsolete("Deprecated in favour of \"Return\"")] + [NativeName("Name", "CTRLINFO_EATS_RETURN")] + CtrlinfoEatsReturn = 0x1, + [Obsolete("Deprecated in favour of \"Escape\"")] + [NativeName("Name", "CTRLINFO_EATS_ESCAPE")] + CtrlinfoEatsEscape = 0x2, + [NativeName("Name", "CTRLINFO_EATS_RETURN")] + Return = 0x1, + [NativeName("Name", "CTRLINFO_EATS_ESCAPE")] + Escape = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/CallConv.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/CallConv.gen.cs new file mode 100644 index 0000000000..37d1f19830 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/CallConv.gen.cs @@ -0,0 +1,71 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCALLCONV")] + public enum CallConv : int + { + [Obsolete("Deprecated in favour of \"Fastcall\"")] + [NativeName("Name", "CC_FASTCALL")] + CCFastcall = 0x0, + [Obsolete("Deprecated in favour of \"Cdecl\"")] + [NativeName("Name", "CC_CDECL")] + CCCdecl = 0x1, + [Obsolete("Deprecated in favour of \"Mscpascal\"")] + [NativeName("Name", "CC_MSCPASCAL")] + CCMscpascal = 0x2, + [Obsolete("Deprecated in favour of \"Pascal\"")] + [NativeName("Name", "CC_PASCAL")] + CCPascal = 0x2, + [Obsolete("Deprecated in favour of \"Macpascal\"")] + [NativeName("Name", "CC_MACPASCAL")] + CCMacpascal = 0x3, + [Obsolete("Deprecated in favour of \"Stdcall\"")] + [NativeName("Name", "CC_STDCALL")] + CCStdcall = 0x4, + [Obsolete("Deprecated in favour of \"Fpfastcall\"")] + [NativeName("Name", "CC_FPFASTCALL")] + CCFpfastcall = 0x5, + [Obsolete("Deprecated in favour of \"Syscall\"")] + [NativeName("Name", "CC_SYSCALL")] + CCSyscall = 0x6, + [Obsolete("Deprecated in favour of \"Mpwcdecl\"")] + [NativeName("Name", "CC_MPWCDECL")] + CCMpwcdecl = 0x7, + [Obsolete("Deprecated in favour of \"Mpwpascal\"")] + [NativeName("Name", "CC_MPWPASCAL")] + CCMpwpascal = 0x8, + [Obsolete("Deprecated in favour of \"Max\"")] + [NativeName("Name", "CC_MAX")] + CCMax = 0x9, + [NativeName("Name", "CC_FASTCALL")] + Fastcall = 0x0, + [NativeName("Name", "CC_CDECL")] + Cdecl = 0x1, + [NativeName("Name", "CC_MSCPASCAL")] + Mscpascal = 0x2, + [NativeName("Name", "CC_PASCAL")] + Pascal = 0x2, + [NativeName("Name", "CC_MACPASCAL")] + Macpascal = 0x3, + [NativeName("Name", "CC_STDCALL")] + Stdcall = 0x4, + [NativeName("Name", "CC_FPFASTCALL")] + Fpfastcall = 0x5, + [NativeName("Name", "CC_SYSCALL")] + Syscall = 0x6, + [NativeName("Name", "CC_MPWCDECL")] + Mpwcdecl = 0x7, + [NativeName("Name", "CC_MPWPASCAL")] + Mpwpascal = 0x8, + [NativeName("Name", "CC_MAX")] + Max = 0x9, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/ChangeKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ChangeKind.gen.cs new file mode 100644 index 0000000000..e208ba9bbc --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ChangeKind.gen.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCHANGEKIND")] + public enum ChangeKind : int + { + [Obsolete("Deprecated in favour of \"Addmember\"")] + [NativeName("Name", "CHANGEKIND_ADDMEMBER")] + ChangekindAddmember = 0x0, + [Obsolete("Deprecated in favour of \"Deletemember\"")] + [NativeName("Name", "CHANGEKIND_DELETEMEMBER")] + ChangekindDeletemember = 0x1, + [Obsolete("Deprecated in favour of \"Setnames\"")] + [NativeName("Name", "CHANGEKIND_SETNAMES")] + ChangekindSetnames = 0x2, + [Obsolete("Deprecated in favour of \"Setdocumentation\"")] + [NativeName("Name", "CHANGEKIND_SETDOCUMENTATION")] + ChangekindSetdocumentation = 0x3, + [Obsolete("Deprecated in favour of \"General\"")] + [NativeName("Name", "CHANGEKIND_GENERAL")] + ChangekindGeneral = 0x4, + [Obsolete("Deprecated in favour of \"Invalidate\"")] + [NativeName("Name", "CHANGEKIND_INVALIDATE")] + ChangekindInvalidate = 0x5, + [Obsolete("Deprecated in favour of \"Changefailed\"")] + [NativeName("Name", "CHANGEKIND_CHANGEFAILED")] + ChangekindChangefailed = 0x6, + [Obsolete("Deprecated in favour of \"Max\"")] + [NativeName("Name", "CHANGEKIND_MAX")] + ChangekindMax = 0x7, + [NativeName("Name", "CHANGEKIND_ADDMEMBER")] + Addmember = 0x0, + [NativeName("Name", "CHANGEKIND_DELETEMEMBER")] + Deletemember = 0x1, + [NativeName("Name", "CHANGEKIND_SETNAMES")] + Setnames = 0x2, + [NativeName("Name", "CHANGEKIND_SETDOCUMENTATION")] + Setdocumentation = 0x3, + [NativeName("Name", "CHANGEKIND_GENERAL")] + General = 0x4, + [NativeName("Name", "CHANGEKIND_INVALIDATE")] + Invalidate = 0x5, + [NativeName("Name", "CHANGEKIND_CHANGEFAILED")] + Changefailed = 0x6, + [NativeName("Name", "CHANGEKIND_MAX")] + Max = 0x7, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT.gen.cs new file mode 100644 index 0000000000..4acc3cfc05 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagDVASPECT")] + public enum DVASPECT : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Content\"")] + [NativeName("Name", "DVASPECT_CONTENT")] + DvaspectContent = 0x1, + [Obsolete("Deprecated in favour of \"Thumbnail\"")] + [NativeName("Name", "DVASPECT_THUMBNAIL")] + DvaspectThumbnail = 0x2, + [Obsolete("Deprecated in favour of \"Icon\"")] + [NativeName("Name", "DVASPECT_ICON")] + DvaspectIcon = 0x4, + [Obsolete("Deprecated in favour of \"Docprint\"")] + [NativeName("Name", "DVASPECT_DOCPRINT")] + DvaspectDocprint = 0x8, + [NativeName("Name", "DVASPECT_CONTENT")] + Content = 0x1, + [NativeName("Name", "DVASPECT_THUMBNAIL")] + Thumbnail = 0x2, + [NativeName("Name", "DVASPECT_ICON")] + Icon = 0x4, + [NativeName("Name", "DVASPECT_DOCPRINT")] + Docprint = 0x8, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT2.gen.cs new file mode 100644 index 0000000000..da00843646 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/DVASPECT2.gen.cs @@ -0,0 +1,29 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagDVASPECT2")] + public enum DVASPECT2 : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Opaque\"")] + [NativeName("Name", "DVASPECT_OPAQUE")] + DvaspectOpaque = 0x10, + [Obsolete("Deprecated in favour of \"Transparent\"")] + [NativeName("Name", "DVASPECT_TRANSPARENT")] + DvaspectTransparent = 0x20, + [NativeName("Name", "DVASPECT_OPAQUE")] + Opaque = 0x10, + [NativeName("Name", "DVASPECT_TRANSPARENT")] + Transparent = 0x20, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/DescKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/DescKind.gen.cs new file mode 100644 index 0000000000..d77e73bbba --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/DescKind.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagDESCKIND")] + public enum DescKind : int + { + [Obsolete("Deprecated in favour of \"None\"")] + [NativeName("Name", "DESCKIND_NONE")] + DesckindNone = 0x0, + [Obsolete("Deprecated in favour of \"Funcdesc\"")] + [NativeName("Name", "DESCKIND_FUNCDESC")] + DesckindFuncdesc = 0x1, + [Obsolete("Deprecated in favour of \"Vardesc\"")] + [NativeName("Name", "DESCKIND_VARDESC")] + DesckindVardesc = 0x2, + [Obsolete("Deprecated in favour of \"Typecomp\"")] + [NativeName("Name", "DESCKIND_TYPECOMP")] + DesckindTypecomp = 0x3, + [Obsolete("Deprecated in favour of \"Implicitappobj\"")] + [NativeName("Name", "DESCKIND_IMPLICITAPPOBJ")] + DesckindImplicitappobj = 0x4, + [Obsolete("Deprecated in favour of \"Max\"")] + [NativeName("Name", "DESCKIND_MAX")] + DesckindMax = 0x5, + [NativeName("Name", "DESCKIND_NONE")] + None = 0x0, + [NativeName("Name", "DESCKIND_FUNCDESC")] + Funcdesc = 0x1, + [NativeName("Name", "DESCKIND_VARDESC")] + Vardesc = 0x2, + [NativeName("Name", "DESCKIND_TYPECOMP")] + Typecomp = 0x3, + [NativeName("Name", "DESCKIND_IMPLICITAPPOBJ")] + Implicitappobj = 0x4, + [NativeName("Name", "DESCKIND_MAX")] + Max = 0x5, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/ExtentMode.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ExtentMode.gen.cs new file mode 100644 index 0000000000..0b9b4c1ce3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ExtentMode.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagExtentMode")] + public enum ExtentMode : int + { + [Obsolete("Deprecated in favour of \"Content\"")] + [NativeName("Name", "DVEXTENT_CONTENT")] + DvextentContent = 0x0, + [Obsolete("Deprecated in favour of \"Integral\"")] + [NativeName("Name", "DVEXTENT_INTEGRAL")] + DvextentIntegral = 0x1, + [NativeName("Name", "DVEXTENT_CONTENT")] + Content = 0x0, + [NativeName("Name", "DVEXTENT_INTEGRAL")] + Integral = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncFlags.gen.cs new file mode 100644 index 0000000000..244c0786d1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncFlags.gen.cs @@ -0,0 +1,84 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagFUNCFLAGS")] + public enum FuncFlags : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Frestricted\"")] + [NativeName("Name", "FUNCFLAG_FRESTRICTED")] + FuncflagFrestricted = 0x1, + [Obsolete("Deprecated in favour of \"Fsource\"")] + [NativeName("Name", "FUNCFLAG_FSOURCE")] + FuncflagFsource = 0x2, + [Obsolete("Deprecated in favour of \"Fbindable\"")] + [NativeName("Name", "FUNCFLAG_FBINDABLE")] + FuncflagFbindable = 0x4, + [Obsolete("Deprecated in favour of \"Frequestedit\"")] + [NativeName("Name", "FUNCFLAG_FREQUESTEDIT")] + FuncflagFrequestedit = 0x8, + [Obsolete("Deprecated in favour of \"Fdisplaybind\"")] + [NativeName("Name", "FUNCFLAG_FDISPLAYBIND")] + FuncflagFdisplaybind = 0x10, + [Obsolete("Deprecated in favour of \"Fdefaultbind\"")] + [NativeName("Name", "FUNCFLAG_FDEFAULTBIND")] + FuncflagFdefaultbind = 0x20, + [Obsolete("Deprecated in favour of \"Fhidden\"")] + [NativeName("Name", "FUNCFLAG_FHIDDEN")] + FuncflagFhidden = 0x40, + [Obsolete("Deprecated in favour of \"Fusesgetlasterror\"")] + [NativeName("Name", "FUNCFLAG_FUSESGETLASTERROR")] + FuncflagFusesgetlasterror = 0x80, + [Obsolete("Deprecated in favour of \"Fdefaultcollelem\"")] + [NativeName("Name", "FUNCFLAG_FDEFAULTCOLLELEM")] + FuncflagFdefaultcollelem = 0x100, + [Obsolete("Deprecated in favour of \"Fuidefault\"")] + [NativeName("Name", "FUNCFLAG_FUIDEFAULT")] + FuncflagFuidefault = 0x200, + [Obsolete("Deprecated in favour of \"Fnonbrowsable\"")] + [NativeName("Name", "FUNCFLAG_FNONBROWSABLE")] + FuncflagFnonbrowsable = 0x400, + [Obsolete("Deprecated in favour of \"Freplaceable\"")] + [NativeName("Name", "FUNCFLAG_FREPLACEABLE")] + FuncflagFreplaceable = 0x800, + [Obsolete("Deprecated in favour of \"Fimmediatebind\"")] + [NativeName("Name", "FUNCFLAG_FIMMEDIATEBIND")] + FuncflagFimmediatebind = 0x1000, + [NativeName("Name", "FUNCFLAG_FRESTRICTED")] + Frestricted = 0x1, + [NativeName("Name", "FUNCFLAG_FSOURCE")] + Fsource = 0x2, + [NativeName("Name", "FUNCFLAG_FBINDABLE")] + Fbindable = 0x4, + [NativeName("Name", "FUNCFLAG_FREQUESTEDIT")] + Frequestedit = 0x8, + [NativeName("Name", "FUNCFLAG_FDISPLAYBIND")] + Fdisplaybind = 0x10, + [NativeName("Name", "FUNCFLAG_FDEFAULTBIND")] + Fdefaultbind = 0x20, + [NativeName("Name", "FUNCFLAG_FHIDDEN")] + Fhidden = 0x40, + [NativeName("Name", "FUNCFLAG_FUSESGETLASTERROR")] + Fusesgetlasterror = 0x80, + [NativeName("Name", "FUNCFLAG_FDEFAULTCOLLELEM")] + Fdefaultcollelem = 0x100, + [NativeName("Name", "FUNCFLAG_FUIDEFAULT")] + Fuidefault = 0x200, + [NativeName("Name", "FUNCFLAG_FNONBROWSABLE")] + Fnonbrowsable = 0x400, + [NativeName("Name", "FUNCFLAG_FREPLACEABLE")] + Freplaceable = 0x800, + [NativeName("Name", "FUNCFLAG_FIMMEDIATEBIND")] + Fimmediatebind = 0x1000, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncKind.gen.cs new file mode 100644 index 0000000000..adb43231c0 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/FuncKind.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagFUNCKIND")] + public enum FuncKind : int + { + [Obsolete("Deprecated in favour of \"Virtual\"")] + [NativeName("Name", "FUNC_VIRTUAL")] + FuncVirtual = 0x0, + [Obsolete("Deprecated in favour of \"Purevirtual\"")] + [NativeName("Name", "FUNC_PUREVIRTUAL")] + FuncPurevirtual = 0x1, + [Obsolete("Deprecated in favour of \"Nonvirtual\"")] + [NativeName("Name", "FUNC_NONVIRTUAL")] + FuncNonvirtual = 0x2, + [Obsolete("Deprecated in favour of \"Static\"")] + [NativeName("Name", "FUNC_STATIC")] + FuncStatic = 0x3, + [Obsolete("Deprecated in favour of \"Dispatch\"")] + [NativeName("Name", "FUNC_DISPATCH")] + FuncDispatch = 0x4, + [NativeName("Name", "FUNC_VIRTUAL")] + Virtual = 0x0, + [NativeName("Name", "FUNC_PUREVIRTUAL")] + Purevirtual = 0x1, + [NativeName("Name", "FUNC_NONVIRTUAL")] + Nonvirtual = 0x2, + [NativeName("Name", "FUNC_STATIC")] + Static = 0x3, + [NativeName("Name", "FUNC_DISPATCH")] + Dispatch = 0x4, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/GuidKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GuidKind.gen.cs new file mode 100644 index 0000000000..87ac36c703 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GuidKind.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagGUIDKIND")] + public enum GuidKind : int + { + [NativeName("Name", "GUIDKIND_DEFAULT_SOURCE_DISP_IID")] + GuidkindDefaultSourceDispIid = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/HitResult.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/HitResult.gen.cs new file mode 100644 index 0000000000..22318cfbe9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/HitResult.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagHITRESULT")] + public enum HitResult : int + { + [Obsolete("Deprecated in favour of \"Outside\"")] + [NativeName("Name", "HITRESULT_OUTSIDE")] + HitresultOutside = 0x0, + [Obsolete("Deprecated in favour of \"Transparent\"")] + [NativeName("Name", "HITRESULT_TRANSPARENT")] + HitresultTransparent = 0x1, + [Obsolete("Deprecated in favour of \"Close\"")] + [NativeName("Name", "HITRESULT_CLOSE")] + HitresultClose = 0x2, + [Obsolete("Deprecated in favour of \"Hit\"")] + [NativeName("Name", "HITRESULT_HIT")] + HitresultHit = 0x3, + [NativeName("Name", "HITRESULT_OUTSIDE")] + Outside = 0x0, + [NativeName("Name", "HITRESULT_TRANSPARENT")] + Transparent = 0x1, + [NativeName("Name", "HITRESULT_CLOSE")] + Close = 0x2, + [NativeName("Name", "HITRESULT_HIT")] + Hit = 0x3, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/InvokeKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/InvokeKind.gen.cs new file mode 100644 index 0000000000..eeefc0aa14 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/InvokeKind.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagINVOKEKIND")] + public enum InvokeKind : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Func\"")] + [NativeName("Name", "INVOKE_FUNC")] + InvokeFunc = 0x1, + [Obsolete("Deprecated in favour of \"Propertyget\"")] + [NativeName("Name", "INVOKE_PROPERTYGET")] + InvokePropertyget = 0x2, + [Obsolete("Deprecated in favour of \"Propertyput\"")] + [NativeName("Name", "INVOKE_PROPERTYPUT")] + InvokePropertyput = 0x4, + [Obsolete("Deprecated in favour of \"Propertyputref\"")] + [NativeName("Name", "INVOKE_PROPERTYPUTREF")] + InvokePropertyputref = 0x8, + [NativeName("Name", "INVOKE_FUNC")] + Func = 0x1, + [NativeName("Name", "INVOKE_PROPERTYGET")] + Propertyget = 0x2, + [NativeName("Name", "INVOKE_PROPERTYPUT")] + Propertyput = 0x4, + [NativeName("Name", "INVOKE_PROPERTYPUTREF")] + Propertyputref = 0x8, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/LibFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/LibFlags.gen.cs new file mode 100644 index 0000000000..c28645cfaa --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/LibFlags.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagLIBFLAGS")] + public enum LibFlags : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Frestricted\"")] + [NativeName("Name", "LIBFLAG_FRESTRICTED")] + LibflagFrestricted = 0x1, + [Obsolete("Deprecated in favour of \"Fcontrol\"")] + [NativeName("Name", "LIBFLAG_FCONTROL")] + LibflagFcontrol = 0x2, + [Obsolete("Deprecated in favour of \"Fhidden\"")] + [NativeName("Name", "LIBFLAG_FHIDDEN")] + LibflagFhidden = 0x4, + [Obsolete("Deprecated in favour of \"Fhasdiskimage\"")] + [NativeName("Name", "LIBFLAG_FHASDISKIMAGE")] + LibflagFhasdiskimage = 0x8, + [NativeName("Name", "LIBFLAG_FRESTRICTED")] + Frestricted = 0x1, + [NativeName("Name", "LIBFLAG_FCONTROL")] + Fcontrol = 0x2, + [NativeName("Name", "LIBFLAG_FHIDDEN")] + Fhidden = 0x4, + [NativeName("Name", "LIBFLAG_FHASDISKIMAGE")] + Fhasdiskimage = 0x8, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/OLEDCFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/OLEDCFlags.gen.cs new file mode 100644 index 0000000000..8dba17a398 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/OLEDCFlags.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagOLEDCFLAGS")] + public enum OLEDCFlags : int + { + [Obsolete("Deprecated in favour of \"Nodraw\"")] + [NativeName("Name", "OLEDC_NODRAW")] + OledcNodraw = 0x1, + [Obsolete("Deprecated in favour of \"Paintbkgnd\"")] + [NativeName("Name", "OLEDC_PAINTBKGND")] + OledcPaintbkgnd = 0x2, + [Obsolete("Deprecated in favour of \"Offscreen\"")] + [NativeName("Name", "OLEDC_OFFSCREEN")] + OledcOffscreen = 0x4, + [NativeName("Name", "OLEDC_NODRAW")] + Nodraw = 0x1, + [NativeName("Name", "OLEDC_PAINTBKGND")] + Paintbkgnd = 0x2, + [NativeName("Name", "OLEDC_OFFSCREEN")] + Offscreen = 0x4, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/PictureAttributes.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PictureAttributes.gen.cs new file mode 100644 index 0000000000..c8651b9692 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PictureAttributes.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPictureAttributes")] + public enum PictureAttributes : int + { + [Obsolete("Deprecated in favour of \"Scalable\"")] + [NativeName("Name", "PICTURE_SCALABLE")] + PictureScalable = 0x1, + [Obsolete("Deprecated in favour of \"Transparent\"")] + [NativeName("Name", "PICTURE_TRANSPARENT")] + PictureTransparent = 0x2, + [NativeName("Name", "PICTURE_SCALABLE")] + Scalable = 0x1, + [NativeName("Name", "PICTURE_TRANSPARENT")] + Transparent = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/PidmsiStatusValue.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PidmsiStatusValue.gen.cs new file mode 100644 index 0000000000..c23530dd5f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PidmsiStatusValue.gen.cs @@ -0,0 +1,66 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "PIDMSI_STATUS_VALUE")] + public enum PidmsiStatusValue : int + { + [Obsolete("Deprecated in favour of \"Normal\"")] + [NativeName("Name", "PIDMSI_STATUS_NORMAL")] + PidmsiStatusNormal = 0x0, + [Obsolete("Deprecated in favour of \"New\"")] + [NativeName("Name", "PIDMSI_STATUS_NEW")] + PidmsiStatusNew = 0x1, + [Obsolete("Deprecated in favour of \"Prelim\"")] + [NativeName("Name", "PIDMSI_STATUS_PRELIM")] + PidmsiStatusPrelim = 0x2, + [Obsolete("Deprecated in favour of \"Draft\"")] + [NativeName("Name", "PIDMSI_STATUS_DRAFT")] + PidmsiStatusDraft = 0x3, + [Obsolete("Deprecated in favour of \"Inprogress\"")] + [NativeName("Name", "PIDMSI_STATUS_INPROGRESS")] + PidmsiStatusInprogress = 0x4, + [Obsolete("Deprecated in favour of \"Edit\"")] + [NativeName("Name", "PIDMSI_STATUS_EDIT")] + PidmsiStatusEdit = 0x5, + [Obsolete("Deprecated in favour of \"Review\"")] + [NativeName("Name", "PIDMSI_STATUS_REVIEW")] + PidmsiStatusReview = 0x6, + [Obsolete("Deprecated in favour of \"Proof\"")] + [NativeName("Name", "PIDMSI_STATUS_PROOF")] + PidmsiStatusProof = 0x7, + [Obsolete("Deprecated in favour of \"Final\"")] + [NativeName("Name", "PIDMSI_STATUS_FINAL")] + PidmsiStatusFinal = 0x8, + [Obsolete("Deprecated in favour of \"Other\"")] + [NativeName("Name", "PIDMSI_STATUS_OTHER")] + PidmsiStatusOther = 0x7FFF, + [NativeName("Name", "PIDMSI_STATUS_NORMAL")] + Normal = 0x0, + [NativeName("Name", "PIDMSI_STATUS_NEW")] + New = 0x1, + [NativeName("Name", "PIDMSI_STATUS_PRELIM")] + Prelim = 0x2, + [NativeName("Name", "PIDMSI_STATUS_DRAFT")] + Draft = 0x3, + [NativeName("Name", "PIDMSI_STATUS_INPROGRESS")] + Inprogress = 0x4, + [NativeName("Name", "PIDMSI_STATUS_EDIT")] + Edit = 0x5, + [NativeName("Name", "PIDMSI_STATUS_REVIEW")] + Review = 0x6, + [NativeName("Name", "PIDMSI_STATUS_PROOF")] + Proof = 0x7, + [NativeName("Name", "PIDMSI_STATUS_FINAL")] + Final = 0x8, + [NativeName("Name", "PIDMSI_STATUS_OTHER")] + Other = 0x7FFF, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/PointerInactive.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PointerInactive.gen.cs new file mode 100644 index 0000000000..b93b2b2c5c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PointerInactive.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPOINTERINACTIVE")] + public enum PointerInactive : int + { + [Obsolete("Deprecated in favour of \"Activateonentry\"")] + [NativeName("Name", "POINTERINACTIVE_ACTIVATEONENTRY")] + PointerinactiveActivateonentry = 0x1, + [Obsolete("Deprecated in favour of \"Deactivateonleave\"")] + [NativeName("Name", "POINTERINACTIVE_DEACTIVATEONLEAVE")] + PointerinactiveDeactivateonleave = 0x2, + [Obsolete("Deprecated in favour of \"Activateondrag\"")] + [NativeName("Name", "POINTERINACTIVE_ACTIVATEONDRAG")] + PointerinactiveActivateondrag = 0x4, + [NativeName("Name", "POINTERINACTIVE_ACTIVATEONENTRY")] + Activateonentry = 0x1, + [NativeName("Name", "POINTERINACTIVE_DEACTIVATEONLEAVE")] + Deactivateonleave = 0x2, + [NativeName("Name", "POINTERINACTIVE_ACTIVATEONDRAG")] + Activateondrag = 0x4, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/PropBag2Type.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PropBag2Type.gen.cs new file mode 100644 index 0000000000..1e2f2945c7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PropBag2Type.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPROPBAG2_TYPE")] + public enum PropBag2Type : int + { + [Obsolete("Deprecated in favour of \"Undefined\"")] + [NativeName("Name", "PROPBAG2_TYPE_UNDEFINED")] + Propbag2TypeUndefined = 0x0, + [Obsolete("Deprecated in favour of \"Data\"")] + [NativeName("Name", "PROPBAG2_TYPE_DATA")] + Propbag2TypeData = 0x1, + [Obsolete("Deprecated in favour of \"Url\"")] + [NativeName("Name", "PROPBAG2_TYPE_URL")] + Propbag2TypeUrl = 0x2, + [Obsolete("Deprecated in favour of \"Object\"")] + [NativeName("Name", "PROPBAG2_TYPE_OBJECT")] + Propbag2TypeObject = 0x3, + [Obsolete("Deprecated in favour of \"Stream\"")] + [NativeName("Name", "PROPBAG2_TYPE_STREAM")] + Propbag2TypeStream = 0x4, + [Obsolete("Deprecated in favour of \"Storage\"")] + [NativeName("Name", "PROPBAG2_TYPE_STORAGE")] + Propbag2TypeStorage = 0x5, + [Obsolete("Deprecated in favour of \"Moniker\"")] + [NativeName("Name", "PROPBAG2_TYPE_MONIKER")] + Propbag2TypeMoniker = 0x6, + [NativeName("Name", "PROPBAG2_TYPE_UNDEFINED")] + Undefined = 0x0, + [NativeName("Name", "PROPBAG2_TYPE_DATA")] + Data = 0x1, + [NativeName("Name", "PROPBAG2_TYPE_URL")] + Url = 0x2, + [NativeName("Name", "PROPBAG2_TYPE_OBJECT")] + Object = 0x3, + [NativeName("Name", "PROPBAG2_TYPE_STREAM")] + Stream = 0x4, + [NativeName("Name", "PROPBAG2_TYPE_STORAGE")] + Storage = 0x5, + [NativeName("Name", "PROPBAG2_TYPE_MONIKER")] + Moniker = 0x6, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/PropPageStatus.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PropPageStatus.gen.cs new file mode 100644 index 0000000000..0c6f542c3f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PropPageStatus.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPROPPAGESTATUS")] + public enum PropPageStatus : int + { + [Obsolete("Deprecated in favour of \"Dirty\"")] + [NativeName("Name", "PROPPAGESTATUS_DIRTY")] + ProppagestatusDirty = 0x1, + [Obsolete("Deprecated in favour of \"Validate\"")] + [NativeName("Name", "PROPPAGESTATUS_VALIDATE")] + ProppagestatusValidate = 0x2, + [Obsolete("Deprecated in favour of \"Clean\"")] + [NativeName("Name", "PROPPAGESTATUS_CLEAN")] + ProppagestatusClean = 0x4, + [NativeName("Name", "PROPPAGESTATUS_DIRTY")] + Dirty = 0x1, + [NativeName("Name", "PROPPAGESTATUS_VALIDATE")] + Validate = 0x2, + [NativeName("Name", "PROPPAGESTATUS_CLEAN")] + Clean = 0x4, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/ReadyState.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ReadyState.gen.cs new file mode 100644 index 0000000000..18fa94aa40 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ReadyState.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagREADYSTATE")] + public enum ReadyState : int + { + [Obsolete("Deprecated in favour of \"Uninitialized\"")] + [NativeName("Name", "READYSTATE_UNINITIALIZED")] + ReadystateUninitialized = 0x0, + [Obsolete("Deprecated in favour of \"Loading\"")] + [NativeName("Name", "READYSTATE_LOADING")] + ReadystateLoading = 0x1, + [Obsolete("Deprecated in favour of \"Loaded\"")] + [NativeName("Name", "READYSTATE_LOADED")] + ReadystateLoaded = 0x2, + [Obsolete("Deprecated in favour of \"Interactive\"")] + [NativeName("Name", "READYSTATE_INTERACTIVE")] + ReadystateInteractive = 0x3, + [Obsolete("Deprecated in favour of \"Complete\"")] + [NativeName("Name", "READYSTATE_COMPLETE")] + ReadystateComplete = 0x4, + [NativeName("Name", "READYSTATE_UNINITIALIZED")] + Uninitialized = 0x0, + [NativeName("Name", "READYSTATE_LOADING")] + Loading = 0x1, + [NativeName("Name", "READYSTATE_LOADED")] + Loaded = 0x2, + [NativeName("Name", "READYSTATE_INTERACTIVE")] + Interactive = 0x3, + [NativeName("Name", "READYSTATE_COMPLETE")] + Complete = 0x4, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/SFType.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/SFType.gen.cs new file mode 100644 index 0000000000..35d083c347 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/SFType.gen.cs @@ -0,0 +1,71 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSF_TYPE")] + public enum SFType : int + { + [Obsolete("Deprecated in favour of \"Error\"")] + [NativeName("Name", "SF_ERROR")] + SFError = 0xA, + [Obsolete("Deprecated in favour of \"I1\"")] + [NativeName("Name", "SF_I1")] + SFI1 = 0x10, + [Obsolete("Deprecated in favour of \"I2\"")] + [NativeName("Name", "SF_I2")] + SFI2 = 0x2, + [Obsolete("Deprecated in favour of \"I4\"")] + [NativeName("Name", "SF_I4")] + SFI4 = 0x3, + [Obsolete("Deprecated in favour of \"I8\"")] + [NativeName("Name", "SF_I8")] + SFI8 = 0x14, + [Obsolete("Deprecated in favour of \"Bstr\"")] + [NativeName("Name", "SF_BSTR")] + SFBstr = 0x8, + [Obsolete("Deprecated in favour of \"Unknown\"")] + [NativeName("Name", "SF_UNKNOWN")] + SFUnknown = 0xD, + [Obsolete("Deprecated in favour of \"Dispatch\"")] + [NativeName("Name", "SF_DISPATCH")] + SFDispatch = 0x9, + [Obsolete("Deprecated in favour of \"Variant\"")] + [NativeName("Name", "SF_VARIANT")] + SFVariant = 0xC, + [Obsolete("Deprecated in favour of \"Record\"")] + [NativeName("Name", "SF_RECORD")] + SFRecord = 0x24, + [Obsolete("Deprecated in favour of \"Haveiid\"")] + [NativeName("Name", "SF_HAVEIID")] + SFHaveiid = 0x800D, + [NativeName("Name", "SF_ERROR")] + Error = 0xA, + [NativeName("Name", "SF_I1")] + I1 = 0x10, + [NativeName("Name", "SF_I2")] + I2 = 0x2, + [NativeName("Name", "SF_I4")] + I4 = 0x3, + [NativeName("Name", "SF_I8")] + I8 = 0x14, + [NativeName("Name", "SF_BSTR")] + Bstr = 0x8, + [NativeName("Name", "SF_UNKNOWN")] + Unknown = 0xD, + [NativeName("Name", "SF_DISPATCH")] + Dispatch = 0x9, + [NativeName("Name", "SF_VARIANT")] + Variant = 0xC, + [NativeName("Name", "SF_RECORD")] + Record = 0x24, + [NativeName("Name", "SF_HAVEIID")] + Haveiid = 0x800D, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/STGC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGC.gen.cs new file mode 100644 index 0000000000..d6d124e5cc --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGC.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSTGC")] + public enum STGC : int + { + [Obsolete("Deprecated in favour of \"Default\"")] + [NativeName("Name", "STGC_DEFAULT")] + StgcDefault = 0x0, + [Obsolete("Deprecated in favour of \"Overwrite\"")] + [NativeName("Name", "STGC_OVERWRITE")] + StgcOverwrite = 0x1, + [Obsolete("Deprecated in favour of \"Onlyifcurrent\"")] + [NativeName("Name", "STGC_ONLYIFCURRENT")] + StgcOnlyifcurrent = 0x2, + [Obsolete("Deprecated in favour of \"Dangerouslycommitmerelytodiskcache\"")] + [NativeName("Name", "STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE")] + StgcDangerouslycommitmerelytodiskcache = 0x4, + [Obsolete("Deprecated in favour of \"Consolidate\"")] + [NativeName("Name", "STGC_CONSOLIDATE")] + StgcConsolidate = 0x8, + [NativeName("Name", "STGC_DEFAULT")] + Default = 0x0, + [NativeName("Name", "STGC_OVERWRITE")] + Overwrite = 0x1, + [NativeName("Name", "STGC_ONLYIFCURRENT")] + Onlyifcurrent = 0x2, + [NativeName("Name", "STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE")] + Dangerouslycommitmerelytodiskcache = 0x4, + [NativeName("Name", "STGC_CONSOLIDATE")] + Consolidate = 0x8, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/STGMove.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGMove.gen.cs new file mode 100644 index 0000000000..62b2353ec1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGMove.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSTGMOVE")] + public enum STGMove : int + { + [Obsolete("Deprecated in favour of \"Move\"")] + [NativeName("Name", "STGMOVE_MOVE")] + StgmoveMove = 0x0, + [Obsolete("Deprecated in favour of \"Copy\"")] + [NativeName("Name", "STGMOVE_COPY")] + StgmoveCopy = 0x1, + [Obsolete("Deprecated in favour of \"Shallowcopy\"")] + [NativeName("Name", "STGMOVE_SHALLOWCOPY")] + StgmoveShallowcopy = 0x2, + [NativeName("Name", "STGMOVE_MOVE")] + Move = 0x0, + [NativeName("Name", "STGMOVE_COPY")] + Copy = 0x1, + [NativeName("Name", "STGMOVE_SHALLOWCOPY")] + Shallowcopy = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/StatFlag.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/StatFlag.gen.cs new file mode 100644 index 0000000000..ff99de0ee0 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/StatFlag.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSTATFLAG")] + public enum StatFlag : int + { + [Obsolete("Deprecated in favour of \"Default\"")] + [NativeName("Name", "STATFLAG_DEFAULT")] + StatflagDefault = 0x0, + [Obsolete("Deprecated in favour of \"Noname\"")] + [NativeName("Name", "STATFLAG_NONAME")] + StatflagNoname = 0x1, + [Obsolete("Deprecated in favour of \"Noopen\"")] + [NativeName("Name", "STATFLAG_NOOPEN")] + StatflagNoopen = 0x2, + [NativeName("Name", "STATFLAG_DEFAULT")] + Default = 0x0, + [NativeName("Name", "STATFLAG_NONAME")] + Noname = 0x1, + [NativeName("Name", "STATFLAG_NOOPEN")] + Noopen = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/SysKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/SysKind.gen.cs new file mode 100644 index 0000000000..6bac9bca00 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/SysKind.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSYSKIND")] + public enum SysKind : int + { + [Obsolete("Deprecated in favour of \"Win16\"")] + [NativeName("Name", "SYS_WIN16")] + SysWin16 = 0x0, + [Obsolete("Deprecated in favour of \"Win32\"")] + [NativeName("Name", "SYS_WIN32")] + SysWin32 = 0x1, + [Obsolete("Deprecated in favour of \"Mac\"")] + [NativeName("Name", "SYS_MAC")] + SysMac = 0x2, + [Obsolete("Deprecated in favour of \"Win64\"")] + [NativeName("Name", "SYS_WIN64")] + SysWin64 = 0x3, + [NativeName("Name", "SYS_WIN16")] + Win16 = 0x0, + [NativeName("Name", "SYS_WIN32")] + Win32 = 0x1, + [NativeName("Name", "SYS_MAC")] + Mac = 0x2, + [NativeName("Name", "SYS_WIN64")] + Win64 = 0x3, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeFlags.gen.cs new file mode 100644 index 0000000000..d1c3b6aaf6 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeFlags.gen.cs @@ -0,0 +1,94 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagTYPEFLAGS")] + public enum TypeFlags : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Fappobject\"")] + [NativeName("Name", "TYPEFLAG_FAPPOBJECT")] + TypeflagFappobject = 0x1, + [Obsolete("Deprecated in favour of \"Fcancreate\"")] + [NativeName("Name", "TYPEFLAG_FCANCREATE")] + TypeflagFcancreate = 0x2, + [Obsolete("Deprecated in favour of \"Flicensed\"")] + [NativeName("Name", "TYPEFLAG_FLICENSED")] + TypeflagFlicensed = 0x4, + [Obsolete("Deprecated in favour of \"Fpredeclid\"")] + [NativeName("Name", "TYPEFLAG_FPREDECLID")] + TypeflagFpredeclid = 0x8, + [Obsolete("Deprecated in favour of \"Fhidden\"")] + [NativeName("Name", "TYPEFLAG_FHIDDEN")] + TypeflagFhidden = 0x10, + [Obsolete("Deprecated in favour of \"Fcontrol\"")] + [NativeName("Name", "TYPEFLAG_FCONTROL")] + TypeflagFcontrol = 0x20, + [Obsolete("Deprecated in favour of \"Fdual\"")] + [NativeName("Name", "TYPEFLAG_FDUAL")] + TypeflagFdual = 0x40, + [Obsolete("Deprecated in favour of \"Fnonextensible\"")] + [NativeName("Name", "TYPEFLAG_FNONEXTENSIBLE")] + TypeflagFnonextensible = 0x80, + [Obsolete("Deprecated in favour of \"Foleautomation\"")] + [NativeName("Name", "TYPEFLAG_FOLEAUTOMATION")] + TypeflagFoleautomation = 0x100, + [Obsolete("Deprecated in favour of \"Frestricted\"")] + [NativeName("Name", "TYPEFLAG_FRESTRICTED")] + TypeflagFrestricted = 0x200, + [Obsolete("Deprecated in favour of \"Faggregatable\"")] + [NativeName("Name", "TYPEFLAG_FAGGREGATABLE")] + TypeflagFaggregatable = 0x400, + [Obsolete("Deprecated in favour of \"Freplaceable\"")] + [NativeName("Name", "TYPEFLAG_FREPLACEABLE")] + TypeflagFreplaceable = 0x800, + [Obsolete("Deprecated in favour of \"Fdispatchable\"")] + [NativeName("Name", "TYPEFLAG_FDISPATCHABLE")] + TypeflagFdispatchable = 0x1000, + [Obsolete("Deprecated in favour of \"Freversebind\"")] + [NativeName("Name", "TYPEFLAG_FREVERSEBIND")] + TypeflagFreversebind = 0x2000, + [Obsolete("Deprecated in favour of \"Fproxy\"")] + [NativeName("Name", "TYPEFLAG_FPROXY")] + TypeflagFproxy = 0x4000, + [NativeName("Name", "TYPEFLAG_FAPPOBJECT")] + Fappobject = 0x1, + [NativeName("Name", "TYPEFLAG_FCANCREATE")] + Fcancreate = 0x2, + [NativeName("Name", "TYPEFLAG_FLICENSED")] + Flicensed = 0x4, + [NativeName("Name", "TYPEFLAG_FPREDECLID")] + Fpredeclid = 0x8, + [NativeName("Name", "TYPEFLAG_FHIDDEN")] + Fhidden = 0x10, + [NativeName("Name", "TYPEFLAG_FCONTROL")] + Fcontrol = 0x20, + [NativeName("Name", "TYPEFLAG_FDUAL")] + Fdual = 0x40, + [NativeName("Name", "TYPEFLAG_FNONEXTENSIBLE")] + Fnonextensible = 0x80, + [NativeName("Name", "TYPEFLAG_FOLEAUTOMATION")] + Foleautomation = 0x100, + [NativeName("Name", "TYPEFLAG_FRESTRICTED")] + Frestricted = 0x200, + [NativeName("Name", "TYPEFLAG_FAGGREGATABLE")] + Faggregatable = 0x400, + [NativeName("Name", "TYPEFLAG_FREPLACEABLE")] + Freplaceable = 0x800, + [NativeName("Name", "TYPEFLAG_FDISPATCHABLE")] + Fdispatchable = 0x1000, + [NativeName("Name", "TYPEFLAG_FREVERSEBIND")] + Freversebind = 0x2000, + [NativeName("Name", "TYPEFLAG_FPROXY")] + Fproxy = 0x4000, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeKind.gen.cs new file mode 100644 index 0000000000..18172734fc --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeKind.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagTYPEKIND")] + public enum TypeKind : int + { + [Obsolete("Deprecated in favour of \"Enum\"")] + [NativeName("Name", "TKIND_ENUM")] + TkindEnum = 0x0, + [Obsolete("Deprecated in favour of \"Record\"")] + [NativeName("Name", "TKIND_RECORD")] + TkindRecord = 0x1, + [Obsolete("Deprecated in favour of \"Module\"")] + [NativeName("Name", "TKIND_MODULE")] + TkindModule = 0x2, + [Obsolete("Deprecated in favour of \"Interface\"")] + [NativeName("Name", "TKIND_INTERFACE")] + TkindInterface = 0x3, + [Obsolete("Deprecated in favour of \"Dispatch\"")] + [NativeName("Name", "TKIND_DISPATCH")] + TkindDispatch = 0x4, + [Obsolete("Deprecated in favour of \"Coclass\"")] + [NativeName("Name", "TKIND_COCLASS")] + TkindCoclass = 0x5, + [Obsolete("Deprecated in favour of \"Alias\"")] + [NativeName("Name", "TKIND_ALIAS")] + TkindAlias = 0x6, + [Obsolete("Deprecated in favour of \"Union\"")] + [NativeName("Name", "TKIND_UNION")] + TkindUnion = 0x7, + [Obsolete("Deprecated in favour of \"Max\"")] + [NativeName("Name", "TKIND_MAX")] + TkindMax = 0x8, + [NativeName("Name", "TKIND_ENUM")] + Enum = 0x0, + [NativeName("Name", "TKIND_RECORD")] + Record = 0x1, + [NativeName("Name", "TKIND_MODULE")] + Module = 0x2, + [NativeName("Name", "TKIND_INTERFACE")] + Interface = 0x3, + [NativeName("Name", "TKIND_DISPATCH")] + Dispatch = 0x4, + [NativeName("Name", "TKIND_COCLASS")] + Coclass = 0x5, + [NativeName("Name", "TKIND_ALIAS")] + Alias = 0x6, + [NativeName("Name", "TKIND_UNION")] + Union = 0x7, + [NativeName("Name", "TKIND_MAX")] + Max = 0x8, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeSpec.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeSpec.gen.cs new file mode 100644 index 0000000000..fb0aebd09e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TypeSpec.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagTYSPEC")] + public enum TypeSpec : int + { + [Obsolete("Deprecated in favour of \"Clsid\"")] + [NativeName("Name", "TYSPEC_CLSID")] + TyspecClsid = 0x0, + [Obsolete("Deprecated in favour of \"Fileext\"")] + [NativeName("Name", "TYSPEC_FILEEXT")] + TyspecFileext = 0x1, + [Obsolete("Deprecated in favour of \"Mimetype\"")] + [NativeName("Name", "TYSPEC_MIMETYPE")] + TyspecMimetype = 0x2, + [Obsolete("Deprecated in favour of \"Filename\"")] + [NativeName("Name", "TYSPEC_FILENAME")] + TyspecFilename = 0x3, + [Obsolete("Deprecated in favour of \"Progid\"")] + [NativeName("Name", "TYSPEC_PROGID")] + TyspecProgid = 0x4, + [Obsolete("Deprecated in favour of \"Packagename\"")] + [NativeName("Name", "TYSPEC_PACKAGENAME")] + TyspecPackagename = 0x5, + [Obsolete("Deprecated in favour of \"Objectid\"")] + [NativeName("Name", "TYSPEC_OBJECTID")] + TyspecObjectid = 0x6, + [NativeName("Name", "TYSPEC_CLSID")] + Clsid = 0x0, + [NativeName("Name", "TYSPEC_FILEEXT")] + Fileext = 0x1, + [NativeName("Name", "TYSPEC_MIMETYPE")] + Mimetype = 0x2, + [NativeName("Name", "TYSPEC_FILENAME")] + Filename = 0x3, + [NativeName("Name", "TYSPEC_PROGID")] + Progid = 0x4, + [NativeName("Name", "TYSPEC_PACKAGENAME")] + Packagename = 0x5, + [NativeName("Name", "TYSPEC_OBJECTID")] + Objectid = 0x6, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/UASFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/UASFlags.gen.cs new file mode 100644 index 0000000000..f7f4659fc9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/UASFlags.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagUASFLAGS")] + public enum UASFlags : int + { + [Obsolete("Deprecated in favour of \"Normal\"")] + [NativeName("Name", "UAS_NORMAL")] + UasNormal = 0x0, + [Obsolete("Deprecated in favour of \"Blocked\"")] + [NativeName("Name", "UAS_BLOCKED")] + UasBlocked = 0x1, + [Obsolete("Deprecated in favour of \"Noparentenable\"")] + [NativeName("Name", "UAS_NOPARENTENABLE")] + UasNoparentenable = 0x2, + [Obsolete("Deprecated in favour of \"Mask\"")] + [NativeName("Name", "UAS_MASK")] + UasMask = 0x3, + [NativeName("Name", "UAS_NORMAL")] + Normal = 0x0, + [NativeName("Name", "UAS_BLOCKED")] + Blocked = 0x1, + [NativeName("Name", "UAS_NOPARENTENABLE")] + Noparentenable = 0x2, + [NativeName("Name", "UAS_MASK")] + Mask = 0x3, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/VarFlags.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/VarFlags.gen.cs new file mode 100644 index 0000000000..b919da56af --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/VarFlags.gen.cs @@ -0,0 +1,84 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagVARFLAGS")] + public enum VarFlags : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Freadonly\"")] + [NativeName("Name", "VARFLAG_FREADONLY")] + VarflagFreadonly = 0x1, + [Obsolete("Deprecated in favour of \"Fsource\"")] + [NativeName("Name", "VARFLAG_FSOURCE")] + VarflagFsource = 0x2, + [Obsolete("Deprecated in favour of \"Fbindable\"")] + [NativeName("Name", "VARFLAG_FBINDABLE")] + VarflagFbindable = 0x4, + [Obsolete("Deprecated in favour of \"Frequestedit\"")] + [NativeName("Name", "VARFLAG_FREQUESTEDIT")] + VarflagFrequestedit = 0x8, + [Obsolete("Deprecated in favour of \"Fdisplaybind\"")] + [NativeName("Name", "VARFLAG_FDISPLAYBIND")] + VarflagFdisplaybind = 0x10, + [Obsolete("Deprecated in favour of \"Fdefaultbind\"")] + [NativeName("Name", "VARFLAG_FDEFAULTBIND")] + VarflagFdefaultbind = 0x20, + [Obsolete("Deprecated in favour of \"Fhidden\"")] + [NativeName("Name", "VARFLAG_FHIDDEN")] + VarflagFhidden = 0x40, + [Obsolete("Deprecated in favour of \"Frestricted\"")] + [NativeName("Name", "VARFLAG_FRESTRICTED")] + VarflagFrestricted = 0x80, + [Obsolete("Deprecated in favour of \"Fdefaultcollelem\"")] + [NativeName("Name", "VARFLAG_FDEFAULTCOLLELEM")] + VarflagFdefaultcollelem = 0x100, + [Obsolete("Deprecated in favour of \"Fuidefault\"")] + [NativeName("Name", "VARFLAG_FUIDEFAULT")] + VarflagFuidefault = 0x200, + [Obsolete("Deprecated in favour of \"Fnonbrowsable\"")] + [NativeName("Name", "VARFLAG_FNONBROWSABLE")] + VarflagFnonbrowsable = 0x400, + [Obsolete("Deprecated in favour of \"Freplaceable\"")] + [NativeName("Name", "VARFLAG_FREPLACEABLE")] + VarflagFreplaceable = 0x800, + [Obsolete("Deprecated in favour of \"Fimmediatebind\"")] + [NativeName("Name", "VARFLAG_FIMMEDIATEBIND")] + VarflagFimmediatebind = 0x1000, + [NativeName("Name", "VARFLAG_FREADONLY")] + Freadonly = 0x1, + [NativeName("Name", "VARFLAG_FSOURCE")] + Fsource = 0x2, + [NativeName("Name", "VARFLAG_FBINDABLE")] + Fbindable = 0x4, + [NativeName("Name", "VARFLAG_FREQUESTEDIT")] + Frequestedit = 0x8, + [NativeName("Name", "VARFLAG_FDISPLAYBIND")] + Fdisplaybind = 0x10, + [NativeName("Name", "VARFLAG_FDEFAULTBIND")] + Fdefaultbind = 0x20, + [NativeName("Name", "VARFLAG_FHIDDEN")] + Fhidden = 0x40, + [NativeName("Name", "VARFLAG_FRESTRICTED")] + Frestricted = 0x80, + [NativeName("Name", "VARFLAG_FDEFAULTCOLLELEM")] + Fdefaultcollelem = 0x100, + [NativeName("Name", "VARFLAG_FUIDEFAULT")] + Fuidefault = 0x200, + [NativeName("Name", "VARFLAG_FNONBROWSABLE")] + Fnonbrowsable = 0x400, + [NativeName("Name", "VARFLAG_FREPLACEABLE")] + Freplaceable = 0x800, + [NativeName("Name", "VARFLAG_FIMMEDIATEBIND")] + Fimmediatebind = 0x1000, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/VarKind.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/VarKind.gen.cs new file mode 100644 index 0000000000..30fc8dc220 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/VarKind.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagVARKIND")] + public enum VarKind : int + { + [Obsolete("Deprecated in favour of \"Perinstance\"")] + [NativeName("Name", "VAR_PERINSTANCE")] + VarPerinstance = 0x0, + [Obsolete("Deprecated in favour of \"Static\"")] + [NativeName("Name", "VAR_STATIC")] + VarStatic = 0x1, + [Obsolete("Deprecated in favour of \"Const\"")] + [NativeName("Name", "VAR_CONST")] + VarConst = 0x2, + [Obsolete("Deprecated in favour of \"Dispatch\"")] + [NativeName("Name", "VAR_DISPATCH")] + VarDispatch = 0x3, + [NativeName("Name", "VAR_PERINSTANCE")] + Perinstance = 0x0, + [NativeName("Name", "VAR_STATIC")] + Static = 0x1, + [NativeName("Name", "VAR_CONST")] + Const = 0x2, + [NativeName("Name", "VAR_DISPATCH")] + Dispatch = 0x3, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/Varenum.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/Varenum.gen.cs new file mode 100644 index 0000000000..aa8d7ddb5f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/Varenum.gen.cs @@ -0,0 +1,276 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "VARENUM")] + public enum Varenum : int + { + [Obsolete("Deprecated in favour of \"Empty\"")] + [NativeName("Name", "VT_EMPTY")] + VTEmpty = 0x0, + [Obsolete("Deprecated in favour of \"Null\"")] + [NativeName("Name", "VT_NULL")] + VTNull = 0x1, + [Obsolete("Deprecated in favour of \"I2\"")] + [NativeName("Name", "VT_I2")] + VTI2 = 0x2, + [Obsolete("Deprecated in favour of \"I4\"")] + [NativeName("Name", "VT_I4")] + VTI4 = 0x3, + [Obsolete("Deprecated in favour of \"R4\"")] + [NativeName("Name", "VT_R4")] + VTR4 = 0x4, + [Obsolete("Deprecated in favour of \"R8\"")] + [NativeName("Name", "VT_R8")] + VTR8 = 0x5, + [Obsolete("Deprecated in favour of \"CY\"")] + [NativeName("Name", "VT_CY")] + VTCY = 0x6, + [Obsolete("Deprecated in favour of \"Date\"")] + [NativeName("Name", "VT_DATE")] + VTDate = 0x7, + [Obsolete("Deprecated in favour of \"Bstr\"")] + [NativeName("Name", "VT_BSTR")] + VTBstr = 0x8, + [Obsolete("Deprecated in favour of \"Dispatch\"")] + [NativeName("Name", "VT_DISPATCH")] + VTDispatch = 0x9, + [Obsolete("Deprecated in favour of \"Error\"")] + [NativeName("Name", "VT_ERROR")] + VTError = 0xA, + [Obsolete("Deprecated in favour of \"Bool\"")] + [NativeName("Name", "VT_BOOL")] + VTBool = 0xB, + [Obsolete("Deprecated in favour of \"Variant\"")] + [NativeName("Name", "VT_VARIANT")] + VTVariant = 0xC, + [Obsolete("Deprecated in favour of \"Unknown\"")] + [NativeName("Name", "VT_UNKNOWN")] + VTUnknown = 0xD, + [Obsolete("Deprecated in favour of \"Decimal\"")] + [NativeName("Name", "VT_DECIMAL")] + VTDecimal = 0xE, + [Obsolete("Deprecated in favour of \"I1\"")] + [NativeName("Name", "VT_I1")] + VTI1 = 0x10, + [Obsolete("Deprecated in favour of \"UI1\"")] + [NativeName("Name", "VT_UI1")] + VTUI1 = 0x11, + [Obsolete("Deprecated in favour of \"UI2\"")] + [NativeName("Name", "VT_UI2")] + VTUI2 = 0x12, + [Obsolete("Deprecated in favour of \"UI4\"")] + [NativeName("Name", "VT_UI4")] + VTUI4 = 0x13, + [Obsolete("Deprecated in favour of \"I8\"")] + [NativeName("Name", "VT_I8")] + VTI8 = 0x14, + [Obsolete("Deprecated in favour of \"UI8\"")] + [NativeName("Name", "VT_UI8")] + VTUI8 = 0x15, + [Obsolete("Deprecated in favour of \"Int\"")] + [NativeName("Name", "VT_INT")] + VTInt = 0x16, + [Obsolete("Deprecated in favour of \"Uint\"")] + [NativeName("Name", "VT_UINT")] + VTUint = 0x17, + [Obsolete("Deprecated in favour of \"Void\"")] + [NativeName("Name", "VT_VOID")] + VTVoid = 0x18, + [Obsolete("Deprecated in favour of \"Hresult\"")] + [NativeName("Name", "VT_HRESULT")] + VTHresult = 0x19, + [Obsolete("Deprecated in favour of \"Ptr\"")] + [NativeName("Name", "VT_PTR")] + VTPtr = 0x1A, + [Obsolete("Deprecated in favour of \"Safearray\"")] + [NativeName("Name", "VT_SAFEARRAY")] + VTSafearray = 0x1B, + [Obsolete("Deprecated in favour of \"Carray\"")] + [NativeName("Name", "VT_CARRAY")] + VTCarray = 0x1C, + [Obsolete("Deprecated in favour of \"Userdefined\"")] + [NativeName("Name", "VT_USERDEFINED")] + VTUserdefined = 0x1D, + [Obsolete("Deprecated in favour of \"Lpstr\"")] + [NativeName("Name", "VT_LPSTR")] + VTLpstr = 0x1E, + [Obsolete("Deprecated in favour of \"Lpwstr\"")] + [NativeName("Name", "VT_LPWSTR")] + VTLpwstr = 0x1F, + [Obsolete("Deprecated in favour of \"Record\"")] + [NativeName("Name", "VT_RECORD")] + VTRecord = 0x24, + [Obsolete("Deprecated in favour of \"IntPtr\"")] + [NativeName("Name", "VT_INT_PTR")] + VTIntPtr = 0x25, + [Obsolete("Deprecated in favour of \"UintPtr\"")] + [NativeName("Name", "VT_UINT_PTR")] + VTUintPtr = 0x26, + [Obsolete("Deprecated in favour of \"Filetime\"")] + [NativeName("Name", "VT_FILETIME")] + VTFiletime = 0x40, + [Obsolete("Deprecated in favour of \"Blob\"")] + [NativeName("Name", "VT_BLOB")] + VTBlob = 0x41, + [Obsolete("Deprecated in favour of \"Stream\"")] + [NativeName("Name", "VT_STREAM")] + VTStream = 0x42, + [Obsolete("Deprecated in favour of \"Storage\"")] + [NativeName("Name", "VT_STORAGE")] + VTStorage = 0x43, + [Obsolete("Deprecated in favour of \"StreamedObject\"")] + [NativeName("Name", "VT_STREAMED_OBJECT")] + VTStreamedObject = 0x44, + [Obsolete("Deprecated in favour of \"StoredObject\"")] + [NativeName("Name", "VT_STORED_OBJECT")] + VTStoredObject = 0x45, + [Obsolete("Deprecated in favour of \"BlobObject\"")] + [NativeName("Name", "VT_BLOB_OBJECT")] + VTBlobObject = 0x46, + [Obsolete("Deprecated in favour of \"CF\"")] + [NativeName("Name", "VT_CF")] + VTCF = 0x47, + [Obsolete("Deprecated in favour of \"Clsid\"")] + [NativeName("Name", "VT_CLSID")] + VTClsid = 0x48, + [Obsolete("Deprecated in favour of \"VersionedStream\"")] + [NativeName("Name", "VT_VERSIONED_STREAM")] + VTVersionedStream = 0x49, + [Obsolete("Deprecated in favour of \"BstrBlob\"")] + [NativeName("Name", "VT_BSTR_BLOB")] + VTBstrBlob = 0xFFF, + [Obsolete("Deprecated in favour of \"Vector\"")] + [NativeName("Name", "VT_VECTOR")] + VTVector = 0x1000, + [Obsolete("Deprecated in favour of \"Array\"")] + [NativeName("Name", "VT_ARRAY")] + VTArray = 0x2000, + [Obsolete("Deprecated in favour of \"Byref\"")] + [NativeName("Name", "VT_BYREF")] + VTByref = 0x4000, + [Obsolete("Deprecated in favour of \"Reserved\"")] + [NativeName("Name", "VT_RESERVED")] + VTReserved = 0x8000, + [Obsolete("Deprecated in favour of \"Illegal\"")] + [NativeName("Name", "VT_ILLEGAL")] + VTIllegal = 0xFFFF, + [Obsolete("Deprecated in favour of \"Illegalmasked\"")] + [NativeName("Name", "VT_ILLEGALMASKED")] + VTIllegalmasked = 0xFFF, + [Obsolete("Deprecated in favour of \"Typemask\"")] + [NativeName("Name", "VT_TYPEMASK")] + VTTypemask = 0xFFF, + [NativeName("Name", "VT_EMPTY")] + Empty = 0x0, + [NativeName("Name", "VT_NULL")] + Null = 0x1, + [NativeName("Name", "VT_I2")] + I2 = 0x2, + [NativeName("Name", "VT_I4")] + I4 = 0x3, + [NativeName("Name", "VT_R4")] + R4 = 0x4, + [NativeName("Name", "VT_R8")] + R8 = 0x5, + [NativeName("Name", "VT_CY")] + CY = 0x6, + [NativeName("Name", "VT_DATE")] + Date = 0x7, + [NativeName("Name", "VT_BSTR")] + Bstr = 0x8, + [NativeName("Name", "VT_DISPATCH")] + Dispatch = 0x9, + [NativeName("Name", "VT_ERROR")] + Error = 0xA, + [NativeName("Name", "VT_BOOL")] + Bool = 0xB, + [NativeName("Name", "VT_VARIANT")] + Variant = 0xC, + [NativeName("Name", "VT_UNKNOWN")] + Unknown = 0xD, + [NativeName("Name", "VT_DECIMAL")] + Decimal = 0xE, + [NativeName("Name", "VT_I1")] + I1 = 0x10, + [NativeName("Name", "VT_UI1")] + UI1 = 0x11, + [NativeName("Name", "VT_UI2")] + UI2 = 0x12, + [NativeName("Name", "VT_UI4")] + UI4 = 0x13, + [NativeName("Name", "VT_I8")] + I8 = 0x14, + [NativeName("Name", "VT_UI8")] + UI8 = 0x15, + [NativeName("Name", "VT_INT")] + Int = 0x16, + [NativeName("Name", "VT_UINT")] + Uint = 0x17, + [NativeName("Name", "VT_VOID")] + Void = 0x18, + [NativeName("Name", "VT_HRESULT")] + Hresult = 0x19, + [NativeName("Name", "VT_PTR")] + Ptr = 0x1A, + [NativeName("Name", "VT_SAFEARRAY")] + Safearray = 0x1B, + [NativeName("Name", "VT_CARRAY")] + Carray = 0x1C, + [NativeName("Name", "VT_USERDEFINED")] + Userdefined = 0x1D, + [NativeName("Name", "VT_LPSTR")] + Lpstr = 0x1E, + [NativeName("Name", "VT_LPWSTR")] + Lpwstr = 0x1F, + [NativeName("Name", "VT_RECORD")] + Record = 0x24, + [NativeName("Name", "VT_INT_PTR")] + IntPtr = 0x25, + [NativeName("Name", "VT_UINT_PTR")] + UintPtr = 0x26, + [NativeName("Name", "VT_FILETIME")] + Filetime = 0x40, + [NativeName("Name", "VT_BLOB")] + Blob = 0x41, + [NativeName("Name", "VT_STREAM")] + Stream = 0x42, + [NativeName("Name", "VT_STORAGE")] + Storage = 0x43, + [NativeName("Name", "VT_STREAMED_OBJECT")] + StreamedObject = 0x44, + [NativeName("Name", "VT_STORED_OBJECT")] + StoredObject = 0x45, + [NativeName("Name", "VT_BLOB_OBJECT")] + BlobObject = 0x46, + [NativeName("Name", "VT_CF")] + CF = 0x47, + [NativeName("Name", "VT_CLSID")] + Clsid = 0x48, + [NativeName("Name", "VT_VERSIONED_STREAM")] + VersionedStream = 0x49, + [NativeName("Name", "VT_BSTR_BLOB")] + BstrBlob = 0xFFF, + [NativeName("Name", "VT_VECTOR")] + Vector = 0x1000, + [NativeName("Name", "VT_ARRAY")] + Array = 0x2000, + [NativeName("Name", "VT_BYREF")] + Byref = 0x4000, + [NativeName("Name", "VT_RESERVED")] + Reserved = 0x8000, + [NativeName("Name", "VT_ILLEGAL")] + Illegal = 0xFFFF, + [NativeName("Name", "VT_ILLEGALMASKED")] + Illegalmasked = 0xFFF, + [NativeName("Name", "VT_TYPEMASK")] + Typemask = 0xFFF, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/ViewStatus.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ViewStatus.gen.cs new file mode 100644 index 0000000000..53c12a0f41 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ViewStatus.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagVIEWSTATUS")] + public enum ViewStatus : int + { + [NativeName("Name", "")] + None = 0, + [NativeName("Name", "VIEWSTATUS_OPAQUE")] + ViewstatusOpaque = 0x1, + [NativeName("Name", "VIEWSTATUS_SOLIDBKGND")] + ViewstatusSolidbkgnd = 0x2, + [NativeName("Name", "VIEWSTATUS_DVASPECTOPAQUE")] + ViewstatusDvaspectopaque = 0x4, + [NativeName("Name", "VIEWSTATUS_DVASPECTTRANSPARENT")] + ViewstatusDvaspecttransparent = 0x8, + [NativeName("Name", "VIEWSTATUS_SURFACE")] + ViewstatusSurface = 0x10, + [NativeName("Name", "VIEWSTATUS_3DSURFACE")] + Viewstatus3Dsurface = 0x20, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/XFormCoords.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/XFormCoords.gen.cs new file mode 100644 index 0000000000..b25173cf55 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/XFormCoords.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagXFORMCOORDS")] + public enum XFormCoords : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Position\"")] + [NativeName("Name", "XFORMCOORDS_POSITION")] + XformcoordsPosition = 0x1, + [Obsolete("Deprecated in favour of \"Size\"")] + [NativeName("Name", "XFORMCOORDS_SIZE")] + XformcoordsSize = 0x2, + [Obsolete("Deprecated in favour of \"Himetrictocontainer\"")] + [NativeName("Name", "XFORMCOORDS_HIMETRICTOCONTAINER")] + XformcoordsHimetrictocontainer = 0x4, + [Obsolete("Deprecated in favour of \"Containertohimetric\"")] + [NativeName("Name", "XFORMCOORDS_CONTAINERTOHIMETRIC")] + XformcoordsContainertohimetric = 0x8, + [Obsolete("Deprecated in favour of \"Eventcompat\"")] + [NativeName("Name", "XFORMCOORDS_EVENTCOMPAT")] + XformcoordsEventcompat = 0x10, + [NativeName("Name", "XFORMCOORDS_POSITION")] + Position = 0x1, + [NativeName("Name", "XFORMCOORDS_SIZE")] + Size = 0x2, + [NativeName("Name", "XFORMCOORDS_HIMETRICTOCONTAINER")] + Himetrictocontainer = 0x4, + [NativeName("Name", "XFORMCOORDS_CONTAINERTOHIMETRIC")] + Containertohimetric = 0x8, + [NativeName("Name", "XFORMCOORDS_EVENTCOMPAT")] + Eventcompat = 0x10, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Silk.NET.Core.Win32Extras.csproj b/src/Core/Silk.NET.Core.Win32Extras/Silk.NET.Core.Win32Extras.csproj index 222c98e1d4..9409b0f132 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Silk.NET.Core.Win32Extras.csproj +++ b/src/Core/Silk.NET.Core.Win32Extras/Silk.NET.Core.Win32Extras.csproj @@ -7,6 +7,7 @@ + diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkExVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkExVtblExtensions.gen.cs new file mode 100644 index 0000000000..77bd30d87f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkExVtblExtensions.gen.cs @@ -0,0 +1,246 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class AdviseSinkExVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public static void OnViewChange(this ComPtr thisVtbl, uint dwAspect, int lindex) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public static unsafe void OnRename(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public static void OnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public static void OnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public static void OnViewStatusChange(this ComPtr thisVtbl, uint dwViewStatus) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwViewStatus); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, STGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnRename(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ArrayDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ArrayDesc.gen.cs new file mode 100644 index 0000000000..48a5741401 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ArrayDesc.gen.cs @@ -0,0 +1,81 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagARRAYDESC")] + public unsafe partial struct ArrayDesc + { + public ArrayDesc + ( + TypeDesc? tdescElem = null, + ushort? cDims = null + ) : this() + { + if (tdescElem is not null) + { + TdescElem = tdescElem.Value; + } + + if (cDims is not null) + { + CDims = cDims.Value; + } + } + + + [NativeName("Type", "TYPEDESC")] + [NativeName("Type.Name", "TYPEDESC")] + [NativeName("Name", "tdescElem")] + public TypeDesc TdescElem; + + [NativeName("Type", "USHORT")] + [NativeName("Type.Name", "USHORT")] + [NativeName("Name", "cDims")] + public ushort CDims; + + [NativeName("Type", "SAFEARRAYBOUND[1]")] + [NativeName("Type.Name", "SAFEARRAYBOUND[1]")] + [NativeName("Name", "rgbounds")] + public RgboundsBuffer Rgbounds; + + public struct RgboundsBuffer + { + public SafeArrayBound Element0; + public ref SafeArrayBound this[int index] + { + get + { + if (index > 0 || index < 0) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + fixed (SafeArrayBound* ptr = &Element0) + { + return ref ptr[index]; + } + } + } + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public Span AsSpan() + => MemoryMarshal.CreateSpan(ref Element0, 1); +#endif + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AspectInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AspectInfo.gen.cs new file mode 100644 index 0000000000..53e5c0e9ce --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AspectInfo.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagAspectInfo")] + public unsafe partial struct AspectInfo + { + public AspectInfo + ( + uint? cb = null, + uint? dwFlags = null + ) : this() + { + if (cb is not null) + { + Cb = cb.Value; + } + + if (dwFlags is not null) + { + DwFlags = dwFlags.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cb")] + public uint Cb; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwFlags")] + public uint DwFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/BSTRBlob.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BSTRBlob.gen.cs new file mode 100644 index 0000000000..568851bd63 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BSTRBlob.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagBSTRBLOB")] + public unsafe partial struct BSTRBlob + { + public BSTRBlob + ( + uint? cbSize = null, + byte* pData = null + ) : this() + { + if (cbSize is not null) + { + CbSize = cbSize.Value; + } + + if (pData is not null) + { + PData = pData; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cbSize")] + public uint CbSize; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "pData")] + public byte* PData; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/BindPtr.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindPtr.gen.cs new file mode 100644 index 0000000000..244bf11dda --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindPtr.gen.cs @@ -0,0 +1,65 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit)] + [NativeName("Name", "tagBINDPTR")] + public unsafe partial struct BindPtr + { + public BindPtr + ( + FuncDesc* lpfuncdesc = null, + VarDesc* lpvardesc = null, + ITypeComp* lptcomp = null + ) : this() + { + if (lpfuncdesc is not null) + { + Lpfuncdesc = lpfuncdesc; + } + + if (lpvardesc is not null) + { + Lpvardesc = lpvardesc; + } + + if (lptcomp is not null) + { + Lptcomp = lptcomp; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "FUNCDESC *")] + [NativeName("Type.Name", "FUNCDESC *")] + [NativeName("Name", "lpfuncdesc")] + public FuncDesc* Lpfuncdesc; + + [FieldOffset(0)] + [NativeName("Type", "VARDESC *")] + [NativeName("Type.Name", "VARDESC *")] + [NativeName("Name", "lpvardesc")] + public VarDesc* Lpvardesc; + + [FieldOffset(0)] + [NativeName("Type", "ITypeComp *")] + [NativeName("Type.Name", "ITypeComp *")] + [NativeName("Name", "lptcomp")] + public ITypeComp* Lptcomp; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTR.gen.cs new file mode 100644 index 0000000000..b720da2f60 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTR.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagCABSTR")] + public unsafe partial struct CABSTR + { + public CABSTR + ( + uint? cElems = null, + char** pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "BSTR *")] + [NativeName("Type.Name", "BSTR *")] + [NativeName("Name", "pElems")] + public char** PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTRBlob.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTRBlob.gen.cs new file mode 100644 index 0000000000..f8ef5fdf76 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABSTRBlob.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCABSTRBLOB")] + public unsafe partial struct CABSTRBlob + { + public CABSTRBlob + ( + uint? cElems = null, + BSTRBlob* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "BSTRBLOB *")] + [NativeName("Type.Name", "BSTRBLOB *")] + [NativeName("Name", "pElems")] + public BSTRBlob* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CABool.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABool.gen.cs new file mode 100644 index 0000000000..2999c69ca6 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CABool.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCABOOL")] + public unsafe partial struct CABool + { + public CABool + ( + uint? cElems = null, + short* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "VARIANT_BOOL *")] + [NativeName("Type.Name", "VARIANT_BOOL *")] + [NativeName("Name", "pElems")] + public short* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAC.gen.cs new file mode 100644 index 0000000000..7f6c071eef --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAC.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAC")] + public unsafe partial struct CAC + { + public CAC + ( + uint? cElems = null, + byte* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "CHAR *")] + [NativeName("Type.Name", "CHAR *")] + [NativeName("Name", "pElems")] + public byte* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CACLSID.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CACLSID.gen.cs new file mode 100644 index 0000000000..6732e4f810 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CACLSID.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCACLSID")] + public unsafe partial struct CACLSID + { + public CACLSID + ( + uint? cElems = null, + Guid* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "CLSID *")] + [NativeName("Type.Name", "CLSID *")] + [NativeName("Name", "pElems")] + public Guid* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CACY.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CACY.gen.cs new file mode 100644 index 0000000000..11b3ef1d65 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CACY.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCACY")] + public unsafe partial struct CACY + { + public CACY + ( + uint? cElems = null, + CY* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "CY *")] + [NativeName("Type.Name", "CY *")] + [NativeName("Name", "pElems")] + public CY* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAClipData.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAClipData.gen.cs new file mode 100644 index 0000000000..2fa865ef97 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAClipData.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCACLIPDATA")] + public unsafe partial struct CAClipData + { + public CAClipData + ( + uint? cElems = null, + ClipData* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "CLIPDATA *")] + [NativeName("Type.Name", "CLIPDATA *")] + [NativeName("Name", "pElems")] + public ClipData* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CADBL.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADBL.gen.cs new file mode 100644 index 0000000000..c97f5be8bd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADBL.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCADBL")] + public unsafe partial struct CADBL + { + public CADBL + ( + uint? cElems = null, + double* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "DOUBLE *")] + [NativeName("Type.Name", "DOUBLE *")] + [NativeName("Name", "pElems")] + public double* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CADWORD.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADWORD.gen.cs new file mode 100644 index 0000000000..a8c4ade3e7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADWORD.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCADWORD")] + public unsafe partial struct CADWORD + { + public CADWORD + ( + uint? cElems = null, + uint* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "DWORD *")] + [NativeName("Type.Name", "DWORD *")] + [NativeName("Name", "pElems")] + public uint* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CADate.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADate.gen.cs new file mode 100644 index 0000000000..0dcf941572 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CADate.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCADATE")] + public unsafe partial struct CADate + { + public CADate + ( + uint? cElems = null, + double* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "DATE *")] + [NativeName("Type.Name", "DATE *")] + [NativeName("Name", "pElems")] + public double* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFLT.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFLT.gen.cs new file mode 100644 index 0000000000..a1531b6f4a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFLT.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAFLT")] + public unsafe partial struct CAFLT + { + public CAFLT + ( + uint? cElems = null, + float* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "FLOAT *")] + [NativeName("Type.Name", "FLOAT *")] + [NativeName("Name", "pElems")] + public float* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFileTime.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFileTime.gen.cs new file mode 100644 index 0000000000..ac495165da --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAFileTime.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAFILETIME")] + public unsafe partial struct CAFileTime + { + public CAFileTime + ( + uint? cElems = null, + Filetime* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "FILETIME *")] + [NativeName("Type.Name", "FILETIME *")] + [NativeName("Name", "pElems")] + public Filetime* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAH.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAH.gen.cs new file mode 100644 index 0000000000..8413d9691c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAH.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAH")] + public unsafe partial struct CAH + { + public CAH + ( + uint? cElems = null, + long* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "LARGE_INTEGER *")] + [NativeName("Type.Name", "LARGE_INTEGER *")] + [NativeName("Name", "pElems")] + public long* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAI.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAI.gen.cs new file mode 100644 index 0000000000..6e60becbba --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAI.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAI")] + public unsafe partial struct CAI + { + public CAI + ( + uint? cElems = null, + short* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "SHORT *")] + [NativeName("Type.Name", "SHORT *")] + [NativeName("Name", "pElems")] + public short* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAL.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAL.gen.cs new file mode 100644 index 0000000000..83ffe3d877 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAL.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAL")] + public unsafe partial struct CAL + { + public CAL + ( + uint? cElems = null, + int* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "LONG *")] + [NativeName("Type.Name", "LONG *")] + [NativeName("Name", "pElems")] + public int* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPOLESTR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPOLESTR.gen.cs new file mode 100644 index 0000000000..d28288589c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPOLESTR.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagCALPOLESTR")] + public unsafe partial struct CALPOLESTR + { + public CALPOLESTR + ( + uint? cElems = null, + char** pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "LPOLESTR *")] + [NativeName("Type.Name", "LPOLESTR *")] + [NativeName("Name", "pElems")] + public char** PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPSTR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPSTR.gen.cs new file mode 100644 index 0000000000..a42c6cec59 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPSTR.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCALPSTR")] + public unsafe partial struct CALPSTR + { + public CALPSTR + ( + uint? cElems = null, + byte** pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "LPSTR *")] + [NativeName("Type.Name", "LPSTR *")] + [NativeName("Name", "pElems")] + public byte** PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPWSTR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPWSTR.gen.cs new file mode 100644 index 0000000000..127cbdf691 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CALPWSTR.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagCALPWSTR")] + public unsafe partial struct CALPWSTR + { + public CALPWSTR + ( + uint? cElems = null, + char** pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "LPWSTR *")] + [NativeName("Type.Name", "LPWSTR *")] + [NativeName("Name", "pElems")] + public char** PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAPropVariant.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAPropVariant.gen.cs new file mode 100644 index 0000000000..a57f25a135 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAPropVariant.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAPROPVARIANT")] + public unsafe partial struct CAPropVariant + { + public CAPropVariant + ( + uint? cElems = null, + PropVariant* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "PROPVARIANT *")] + [NativeName("Type.Name", "PROPVARIANT *")] + [NativeName("Name", "pElems")] + public PropVariant* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CASCode.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CASCode.gen.cs new file mode 100644 index 0000000000..f129ef2f19 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CASCode.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCASCODE")] + public unsafe partial struct CASCode + { + public CASCode + ( + uint? cElems = null, + int* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "SCODE *")] + [NativeName("Type.Name", "SCODE *")] + [NativeName("Name", "pElems")] + public int* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUB.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUB.gen.cs new file mode 100644 index 0000000000..9bbdbcf4e2 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUB.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAUB")] + public unsafe partial struct CAUB + { + public CAUB + ( + uint? cElems = null, + byte* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "UCHAR *")] + [NativeName("Type.Name", "UCHAR *")] + [NativeName("Name", "pElems")] + public byte* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUH.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUH.gen.cs new file mode 100644 index 0000000000..bad0539311 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUH.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAUH")] + public unsafe partial struct CAUH + { + public CAUH + ( + uint? cElems = null, + ulong* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "ULARGE_INTEGER *")] + [NativeName("Type.Name", "ULARGE_INTEGER *")] + [NativeName("Name", "pElems")] + public ulong* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUI.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUI.gen.cs new file mode 100644 index 0000000000..12798ba999 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUI.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAUI")] + public unsafe partial struct CAUI + { + public CAUI + ( + uint? cElems = null, + ushort* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "USHORT *")] + [NativeName("Type.Name", "USHORT *")] + [NativeName("Name", "pElems")] + public ushort* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUL.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUL.gen.cs new file mode 100644 index 0000000000..69531b0300 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUL.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAUL")] + public unsafe partial struct CAUL + { + public CAUL + ( + uint? cElems = null, + uint* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "ULONG *")] + [NativeName("Type.Name", "ULONG *")] + [NativeName("Name", "pElems")] + public uint* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUUID.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUUID.gen.cs new file mode 100644 index 0000000000..f459fc913b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CAUUID.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCAUUID")] + public unsafe partial struct CAUUID + { + public CAUUID + ( + uint? cElems = null, + Guid* pElems = null + ) : this() + { + if (cElems is not null) + { + CElems = cElems.Value; + } + + if (pElems is not null) + { + PElems = pElems; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cElems")] + public uint CElems; + + [NativeName("Type", "GUID *")] + [NativeName("Type.Name", "GUID *")] + [NativeName("Name", "pElems")] + public Guid* PElems; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CleanLocalStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CleanLocalStorage.gen.cs new file mode 100644 index 0000000000..e733f1b872 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CleanLocalStorage.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCLEANLOCALSTORAGE")] + public unsafe partial struct CleanLocalStorage + { + public CleanLocalStorage + ( + Silk.NET.Core.Native.IUnknown* pInterface = null, + void* pStorage = null, + uint? flags = null + ) : this() + { + if (pInterface is not null) + { + PInterface = pInterface; + } + + if (pStorage is not null) + { + PStorage = pStorage; + } + + if (flags is not null) + { + Flags = flags.Value; + } + } + + + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "pInterface")] + public Silk.NET.Core.Native.IUnknown* PInterface; + + [NativeName("Type", "PVOID")] + [NativeName("Type.Name", "PVOID")] + [NativeName("Name", "pStorage")] + public void* PStorage; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "flags")] + public uint Flags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ClipData.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ClipData.gen.cs new file mode 100644 index 0000000000..5a471835e5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ClipData.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCLIPDATA")] + public unsafe partial struct ClipData + { + public ClipData + ( + uint? cbSize = null, + int? ulClipFmt = null, + byte* pClipData = null + ) : this() + { + if (cbSize is not null) + { + CbSize = cbSize.Value; + } + + if (ulClipFmt is not null) + { + UlClipFmt = ulClipFmt.Value; + } + + if (pClipData is not null) + { + PClipData = pClipData; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cbSize")] + public uint CbSize; + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "ulClipFmt")] + public int UlClipFmt; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "pClipData")] + public byte* PClipData; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectData.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectData.gen.cs new file mode 100644 index 0000000000..2bdd7334d3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectData.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCONNECTDATA")] + public unsafe partial struct ConnectData + { + public ConnectData + ( + Silk.NET.Core.Native.IUnknown* pUnk = null, + uint? dwCookie = null + ) : this() + { + if (pUnk is not null) + { + PUnk = pUnk; + } + + if (dwCookie is not null) + { + DwCookie = dwCookie.Value; + } + } + + + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "pUnk")] + public Silk.NET.Core.Native.IUnknown* PUnk; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwCookie")] + public uint DwCookie; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointContainerVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointContainerVtblExtensions.gen.cs new file mode 100644 index 0000000000..f0217bdcf3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointContainerVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ConnectionPointContainerVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int EnumConnectionPoints(this ComPtr thisVtbl, IEnumConnectionPoints** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int EnumConnectionPoints(this ComPtr thisVtbl, ref IEnumConnectionPoints* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumConnectionPoints** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, Guid* riid, IConnectionPoint** ppCP) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppCP); + return ret; + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, Guid* riid, ref IConnectionPoint* ppCP) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppCPPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, ref Guid riid, IConnectionPoint** ppCP) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppCP); + } + return ret; + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, ref Guid riid, ref IConnectionPoint* ppCP) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppCPPtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int EnumConnectionPoints(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumConnectionPoints((IEnumConnectionPoints**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static int FindConnectionPoint(this ComPtr thisVtbl, out ComPtr ppCP) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppCP = default; + return @this->FindConnectionPoint(SilkMarshal.GuidPtrOf(), (IConnectionPoint**) ppCP.GetAddressOf()); + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, Span riid, IConnectionPoint** ppCP) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindConnectionPoint(ref riid.GetPinnableReference(), ppCP); + } + + /// To be documented. + public static int FindConnectionPoint(this ComPtr thisVtbl, ref Guid riid, ref ComPtr ppCP) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindConnectionPoint(ref riid, (IConnectionPoint**) ppCP.GetAddressOf()); + } + + /// To be documented. + public static unsafe int FindConnectionPoint(this ComPtr thisVtbl, Span riid, ref IConnectionPoint* ppCP) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindConnectionPoint(ref riid.GetPinnableReference(), ref ppCP); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr FindConnectionPoint(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->FindConnectionPoint(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointVtblExtensions.gen.cs new file mode 100644 index 0000000000..94c8c7821a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ConnectionPointVtblExtensions.gen.cs @@ -0,0 +1,305 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ConnectionPointVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetConnectionInterface(this ComPtr thisVtbl, Guid* pIID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pIID); + return ret; + } + + /// To be documented. + public static int GetConnectionInterface(this ComPtr thisVtbl, ref Guid pIID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pIIDPtr = &pIID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pIIDPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetConnectionPointContainer(this ComPtr thisVtbl, IConnectionPointContainer** ppCPC) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppCPC); + return ret; + } + + /// To be documented. + public static unsafe int GetConnectionPointContainer(this ComPtr thisVtbl, ref IConnectionPointContainer* ppCPC) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IConnectionPointContainer** ppCPCPtr = &ppCPC) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppCPCPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkSink, uint* pdwCookie) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSink, pdwCookie); + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkSink, ref uint pdwCookie) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwCookiePtr = &pdwCookie) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSink, pdwCookiePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkSink, uint* pdwCookie) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSinkPtr = &pUnkSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSinkPtr, pdwCookie); + } + return ret; + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkSink, ref uint pdwCookie) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSinkPtr = &pUnkSink) + { + fixed (uint* pdwCookiePtr = &pdwCookie) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSinkPtr, pdwCookiePtr); + } + } + return ret; + } + + /// To be documented. + public static int Unadvise(this ComPtr thisVtbl, uint dwCookie) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwCookie); + return ret; + } + + /// To be documented. + public static unsafe int EnumConnections(this ComPtr thisVtbl, IEnumConnections** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int EnumConnections(this ComPtr thisVtbl, ref IEnumConnections* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumConnections** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetConnectionInterface(this ComPtr thisVtbl, Span pIID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetConnectionInterface(ref pIID.GetPinnableReference()); + } + + /// To be documented. + public static int GetConnectionPointContainer(this ComPtr thisVtbl, ref ComPtr ppCPC) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetConnectionPointContainer((IConnectionPointContainer**) ppCPC.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pUnkSink, uint* pdwCookie) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((Silk.NET.Core.Native.IUnknown*) pUnkSink.Handle, pdwCookie); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkSink, Span pdwCookie) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pUnkSink, ref pdwCookie.GetPinnableReference()); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ComPtr pUnkSink, ref uint pdwCookie) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((Silk.NET.Core.Native.IUnknown*) pUnkSink.Handle, ref pdwCookie); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pUnkSink, uint* pdwCookie) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pUnkSink.GetPinnableReference(), pdwCookie); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, Span pUnkSink, Span pdwCookie) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pUnkSink.GetPinnableReference(), ref pdwCookie.GetPinnableReference()); + } + + /// To be documented. + public static int EnumConnections(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumConnections((IEnumConnections**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ControlInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ControlInfo.gen.cs new file mode 100644 index 0000000000..677ff08068 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ControlInfo.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCONTROLINFO")] + public unsafe partial struct ControlInfo + { + public ControlInfo + ( + uint? cb = null, + void* hAccel = null, + ushort? cAccel = null, + uint? dwFlags = null + ) : this() + { + if (cb is not null) + { + Cb = cb.Value; + } + + if (hAccel is not null) + { + HAccel = hAccel; + } + + if (cAccel is not null) + { + CAccel = cAccel.Value; + } + + if (dwFlags is not null) + { + DwFlags = dwFlags.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cb")] + public uint Cb; + + [NativeName("Type", "HACCEL")] + [NativeName("Type.Name", "HACCEL")] + [NativeName("Name", "hAccel")] + public void* HAccel; + + [NativeName("Type", "USHORT")] + [NativeName("Type.Name", "USHORT")] + [NativeName("Name", "cAccel")] + public ushort CAccel; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwFlags")] + public uint DwFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateErrorInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateErrorInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..db905b57c1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateErrorInfoVtblExtensions.gen.cs @@ -0,0 +1,279 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class CreateErrorInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetGUID(this ComPtr thisVtbl, Guid* rguid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguid); + return ret; + } + + /// To be documented. + public static int SetGUID(this ComPtr thisVtbl, ref Guid rguid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidPtr = &rguid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetSource(this ComPtr thisVtbl, char* szSource) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSource); + return ret; + } + + /// To be documented. + public static int SetSource(this ComPtr thisVtbl, ref char szSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szSourcePtr = &szSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSourcePtr); + } + return ret; + } + + /// To be documented. + public static int SetSource(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szSource) + { + var @this = thisVtbl.Handle; + int ret = default; + var szSourcePtr = (byte*) SilkMarshal.StringToPtr(szSource, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSourcePtr); + SilkMarshal.Free((nint)szSourcePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetDescription(this ComPtr thisVtbl, char* szDescription) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescription); + return ret; + } + + /// To be documented. + public static int SetDescription(this ComPtr thisVtbl, ref char szDescription) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDescriptionPtr = &szDescription) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescriptionPtr); + } + return ret; + } + + /// To be documented. + public static int SetDescription(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDescription) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDescriptionPtr = (byte*) SilkMarshal.StringToPtr(szDescription, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescriptionPtr); + SilkMarshal.Free((nint)szDescriptionPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetHelpFile(this ComPtr thisVtbl, char* szHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFile); + return ret; + } + + /// To be documented. + public static int SetHelpFile(this ComPtr thisVtbl, ref char szHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szHelpFilePtr = &szHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static int SetHelpFile(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + var szHelpFilePtr = (byte*) SilkMarshal.StringToPtr(szHelpFile, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFilePtr); + SilkMarshal.Free((nint)szHelpFilePtr); + return ret; + } + + /// To be documented. + public static int SetHelpContext(this ComPtr thisVtbl, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SetGUID(this ComPtr thisVtbl, Span rguid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetGUID(ref rguid.GetPinnableReference()); + } + + /// To be documented. + public static int SetSource(this ComPtr thisVtbl, Span szSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetSource(ref szSource.GetPinnableReference()); + } + + /// To be documented. + public static int SetDescription(this ComPtr thisVtbl, Span szDescription) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDescription(ref szDescription.GetPinnableReference()); + } + + /// To be documented. + public static int SetHelpFile(this ComPtr thisVtbl, Span szHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetHelpFile(ref szHelpFile.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfo2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfo2VtblExtensions.gen.cs new file mode 100644 index 0000000000..a1b2fe4af1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfo2VtblExtensions.gen.cs @@ -0,0 +1,1340 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class CreateTypeInfo2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetGuid(this ComPtr thisVtbl, Guid* guid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guid); + return ret; + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, ref Guid guid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public static int SetTypeFlags(this ComPtr thisVtbl, uint uTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, uTypeFlags); + return ret; + } + + /// To be documented. + public static unsafe int SetDocString(this ComPtr thisVtbl, char* pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDoc); + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, ref char pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrDocPtr = &pStrDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + } + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrDocPtr = (byte*) SilkMarshal.StringToPtr(pStrDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + SilkMarshal.Free((nint)pStrDocPtr); + return ret; + } + + /// To be documented. + public static int SetHelpContext(this ComPtr thisVtbl, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetVersion(this ComPtr thisVtbl, ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefType); + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, ref uint phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefType); + } + return ret; + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTInfo, ref uint phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefTypePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AddFuncDesc(this ComPtr thisVtbl, uint index, FuncDesc* pFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDesc); + return ret; + } + + /// To be documented. + public static int AddFuncDesc(this ComPtr thisVtbl, uint index, ref FuncDesc pFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDescPtr); + } + return ret; + } + + /// To be documented. + public static int AddImplType(this ComPtr thisVtbl, uint index, uint hRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, index, hRefType); + return ret; + } + + /// To be documented. + public static int SetImplTypeFlags(this ComPtr thisVtbl, uint index, int implTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, index, implTypeFlags); + return ret; + } + + /// To be documented. + public static int SetAlignment(this ComPtr thisVtbl, ushort cbAlignment) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, cbAlignment); + return ret; + } + + /// To be documented. + public static unsafe int SetSchema(this ComPtr thisVtbl, char* pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchema); + return ret; + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, ref char pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrSchemaPtr = &pStrSchema) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + } + return ret; + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrSchemaPtr = (byte*) SilkMarshal.StringToPtr(pStrSchema, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + SilkMarshal.Free((nint)pStrSchemaPtr); + return ret; + } + + /// To be documented. + public static unsafe int AddVarDesc(this ComPtr thisVtbl, uint index, VarDesc* pVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDesc); + return ret; + } + + /// To be documented. + public static int AddVarDesc(this ComPtr thisVtbl, uint index, ref VarDesc pVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, char** rgszNames, uint cNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNames, cNames); + return ret; + } + + /// To be documented. + public static unsafe int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, ref char* rgszNames, uint cNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNamesPtr, cNames); + } + return ret; + } + + /// To be documented. + public static unsafe int SetVarName(this ComPtr thisVtbl, uint index, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szName); + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetTypeDescAlias(this ComPtr thisVtbl, TypeDesc* pTDescAlias) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAlias); + return ret; + } + + /// To be documented. + public static int SetTypeDescAlias(this ComPtr thisVtbl, ref TypeDesc pTDescAlias) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeDesc* pTDescAliasPtr = &pTDescAlias) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAliasPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcName); + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + } + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + } + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetFuncDocString(this ComPtr thisVtbl, uint index, char* szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, ref char szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetVarDocString(this ComPtr thisVtbl, uint index, char* szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, ref char szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public static int SetFuncHelpContext(this ComPtr thisVtbl, uint index, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetVarHelpContext(this ComPtr thisVtbl, uint index, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public static unsafe int SetMops(this ComPtr thisVtbl, uint index, char* bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMops); + return ret; + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, ref char bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* bstrMopsPtr = &bstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + } + return ret; + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + var bstrMopsPtr = (byte*) SilkMarshal.StringToPtr(bstrMops, NativeStringEncoding.BStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + SilkMarshal.Free((nint)bstrMopsPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetTypeIdldesc(this ComPtr thisVtbl, IdlDesc* pIdlDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDesc); + return ret; + } + + /// To be documented. + public static int SetTypeIdldesc(this ComPtr thisVtbl, ref IdlDesc pIdlDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IdlDesc* pIdlDescPtr = &pIdlDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDescPtr); + } + return ret; + } + + /// To be documented. + public static int LayOut(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this); + return ret; + } + + /// To be documented. + public static int DeleteFuncDesc(this ComPtr thisVtbl, uint index) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, index); + return ret; + } + + /// To be documented. + public static int DeleteFuncDescByMemId(this ComPtr thisVtbl, int memid, InvokeKind invKind) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, memid, invKind); + return ret; + } + + /// To be documented. + public static int DeleteVarDesc(this ComPtr thisVtbl, uint index) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, index); + return ret; + } + + /// To be documented. + public static int DeleteVarDescByMemId(this ComPtr thisVtbl, int memid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, memid); + return ret; + } + + /// To be documented. + public static int DeleteImplType(this ComPtr thisVtbl, uint index) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index); + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetCustData(this ComPtr thisVtbl, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetFuncCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetFuncCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetVarCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetVarCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetImplTypeCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetImplTypeCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static int SetHelpStringContext(this ComPtr thisVtbl, uint dwHelpStringContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, dwHelpStringContext); + return ret; + } + + /// To be documented. + public static int SetFuncHelpStringContext(this ComPtr thisVtbl, uint index, uint dwHelpStringContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[37])(@this, index, dwHelpStringContext); + return ret; + } + + /// To be documented. + public static int SetVarHelpStringContext(this ComPtr thisVtbl, uint index, uint dwHelpStringContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[38])(@this, index, dwHelpStringContext); + return ret; + } + + /// To be documented. + public static int Invalidate(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[39])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetName(this ComPtr thisVtbl, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szName); + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, Span guid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetGuid(ref guid.GetPinnableReference()); + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, Span pStrDoc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDocString(ref pStrDoc.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ComPtr pTInfo, uint* phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, phRefType); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, Span phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(pTInfo, ref phRefType.GetPinnableReference()); + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, ComPtr pTInfo, ref uint phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, ref phRefType); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, Span pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(ref pTInfo.GetPinnableReference(), phRefType); + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, Span pTInfo, Span phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(ref pTInfo.GetPinnableReference(), ref phRefType.GetPinnableReference()); + } + + /// To be documented. + public static int AddFuncDesc(this ComPtr thisVtbl, uint index, Span pFuncDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddFuncDesc(index, ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, Span pStrSchema) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetSchema(ref pStrSchema.GetPinnableReference()); + } + + /// To be documented. + public static int AddVarDesc(this ComPtr thisVtbl, uint index, Span pVarDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddVarDesc(index, ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + public static int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, string[] rgszNamesSa, uint cNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->SetFuncAndParamNames(index, rgszNames, cNames); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarName(index, ref szName.GetPinnableReference()); + } + + /// To be documented. + public static int SetTypeDescAlias(this ComPtr thisVtbl, Span pTDescAlias) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTypeDescAlias(ref pTDescAlias.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, szDllName, ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), szProcName); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), szProcName); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, szDllName, ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, Span szDocString) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetFuncDocString(index, ref szDocString.GetPinnableReference()); + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, Span szDocString) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarDocString(index, ref szDocString.GetPinnableReference()); + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, Span bstrMops) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMops(index, ref bstrMops.GetPinnableReference()); + } + + /// To be documented. + public static int SetTypeIdldesc(this ComPtr thisVtbl, Span pIdlDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTypeIdldesc(ref pIdlDesc.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetCustData(this ComPtr thisVtbl, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetFuncCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetFuncCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetFuncCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetFuncCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetFuncCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetParamCustData(indexFunc, indexParam, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetParamCustData(indexFunc, indexParam, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetParamCustData(indexFunc, indexParam, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetVarCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetVarCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetImplTypeCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetImplTypeCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetImplTypeCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetImplTypeCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetImplTypeCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetName(ref szName.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..a79909b658 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeInfoVtblExtensions.gen.cs @@ -0,0 +1,859 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class CreateTypeInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetGuid(this ComPtr thisVtbl, Guid* guid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guid); + return ret; + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, ref Guid guid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public static int SetTypeFlags(this ComPtr thisVtbl, uint uTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, uTypeFlags); + return ret; + } + + /// To be documented. + public static unsafe int SetDocString(this ComPtr thisVtbl, char* pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDoc); + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, ref char pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrDocPtr = &pStrDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + } + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrDocPtr = (byte*) SilkMarshal.StringToPtr(pStrDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + SilkMarshal.Free((nint)pStrDocPtr); + return ret; + } + + /// To be documented. + public static int SetHelpContext(this ComPtr thisVtbl, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetVersion(this ComPtr thisVtbl, ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefType); + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, ref uint phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefType); + } + return ret; + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTInfo, ref uint phRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefTypePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AddFuncDesc(this ComPtr thisVtbl, uint index, FuncDesc* pFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDesc); + return ret; + } + + /// To be documented. + public static int AddFuncDesc(this ComPtr thisVtbl, uint index, ref FuncDesc pFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDescPtr); + } + return ret; + } + + /// To be documented. + public static int AddImplType(this ComPtr thisVtbl, uint index, uint hRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, index, hRefType); + return ret; + } + + /// To be documented. + public static int SetImplTypeFlags(this ComPtr thisVtbl, uint index, int implTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, index, implTypeFlags); + return ret; + } + + /// To be documented. + public static int SetAlignment(this ComPtr thisVtbl, ushort cbAlignment) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, cbAlignment); + return ret; + } + + /// To be documented. + public static unsafe int SetSchema(this ComPtr thisVtbl, char* pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchema); + return ret; + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, ref char pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrSchemaPtr = &pStrSchema) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + } + return ret; + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrSchema) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrSchemaPtr = (byte*) SilkMarshal.StringToPtr(pStrSchema, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + SilkMarshal.Free((nint)pStrSchemaPtr); + return ret; + } + + /// To be documented. + public static unsafe int AddVarDesc(this ComPtr thisVtbl, uint index, VarDesc* pVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDesc); + return ret; + } + + /// To be documented. + public static int AddVarDesc(this ComPtr thisVtbl, uint index, ref VarDesc pVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, char** rgszNames, uint cNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNames, cNames); + return ret; + } + + /// To be documented. + public static unsafe int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, ref char* rgszNames, uint cNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNamesPtr, cNames); + } + return ret; + } + + /// To be documented. + public static unsafe int SetVarName(this ComPtr thisVtbl, uint index, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szName); + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetTypeDescAlias(this ComPtr thisVtbl, TypeDesc* pTDescAlias) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAlias); + return ret; + } + + /// To be documented. + public static int SetTypeDescAlias(this ComPtr thisVtbl, ref TypeDesc pTDescAlias) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeDesc* pTDescAliasPtr = &pTDescAlias) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAliasPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcName); + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + } + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + } + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, ref char szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, ref char szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetFuncDocString(this ComPtr thisVtbl, uint index, char* szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, ref char szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetVarDocString(this ComPtr thisVtbl, uint index, char* szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, ref char szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public static int SetFuncHelpContext(this ComPtr thisVtbl, uint index, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetVarHelpContext(this ComPtr thisVtbl, uint index, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public static unsafe int SetMops(this ComPtr thisVtbl, uint index, char* bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMops); + return ret; + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, ref char bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* bstrMopsPtr = &bstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + } + return ret; + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + var bstrMopsPtr = (byte*) SilkMarshal.StringToPtr(bstrMops, NativeStringEncoding.BStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + SilkMarshal.Free((nint)bstrMopsPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetTypeIdldesc(this ComPtr thisVtbl, IdlDesc* pIdlDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDesc); + return ret; + } + + /// To be documented. + public static int SetTypeIdldesc(this ComPtr thisVtbl, ref IdlDesc pIdlDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IdlDesc* pIdlDescPtr = &pIdlDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDescPtr); + } + return ret; + } + + /// To be documented. + public static int LayOut(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, Span guid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetGuid(ref guid.GetPinnableReference()); + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, Span pStrDoc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDocString(ref pStrDoc.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ComPtr pTInfo, uint* phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, phRefType); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTInfo, Span phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(pTInfo, ref phRefType.GetPinnableReference()); + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, ComPtr pTInfo, ref uint phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, ref phRefType); + } + + /// To be documented. + public static unsafe int AddRefTypeInfo(this ComPtr thisVtbl, Span pTInfo, uint* phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(ref pTInfo.GetPinnableReference(), phRefType); + } + + /// To be documented. + public static int AddRefTypeInfo(this ComPtr thisVtbl, Span pTInfo, Span phRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddRefTypeInfo(ref pTInfo.GetPinnableReference(), ref phRefType.GetPinnableReference()); + } + + /// To be documented. + public static int AddFuncDesc(this ComPtr thisVtbl, uint index, Span pFuncDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddFuncDesc(index, ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + public static int SetSchema(this ComPtr thisVtbl, Span pStrSchema) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetSchema(ref pStrSchema.GetPinnableReference()); + } + + /// To be documented. + public static int AddVarDesc(this ComPtr thisVtbl, uint index, Span pVarDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddVarDesc(index, ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + public static int SetFuncAndParamNames(this ComPtr thisVtbl, uint index, string[] rgszNamesSa, uint cNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->SetFuncAndParamNames(index, rgszNames, cNames); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static int SetVarName(this ComPtr thisVtbl, uint index, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarName(index, ref szName.GetPinnableReference()); + } + + /// To be documented. + public static int SetTypeDescAlias(this ComPtr thisVtbl, Span pTDescAlias) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTypeDescAlias(ref pTDescAlias.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, char* szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, szDllName, ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, char* szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), szProcName); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, Span szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, ref szDllName.GetPinnableReference(), szProcName); + } + + /// To be documented. + public static int DefineFuncAsDllEntry(this ComPtr thisVtbl, uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, Span szProcName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DefineFuncAsDllEntry(index, szDllName, ref szProcName.GetPinnableReference()); + } + + /// To be documented. + public static int SetFuncDocString(this ComPtr thisVtbl, uint index, Span szDocString) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetFuncDocString(index, ref szDocString.GetPinnableReference()); + } + + /// To be documented. + public static int SetVarDocString(this ComPtr thisVtbl, uint index, Span szDocString) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetVarDocString(index, ref szDocString.GetPinnableReference()); + } + + /// To be documented. + public static int SetMops(this ComPtr thisVtbl, uint index, Span bstrMops) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMops(index, ref bstrMops.GetPinnableReference()); + } + + /// To be documented. + public static int SetTypeIdldesc(this ComPtr thisVtbl, Span pIdlDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTypeIdldesc(ref pIdlDesc.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLib2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLib2VtblExtensions.gen.cs new file mode 100644 index 0000000000..f8f0ea8b45 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLib2VtblExtensions.gen.cs @@ -0,0 +1,589 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class CreateTypeLib2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfo); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetName(this ComPtr thisVtbl, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName); + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static int SetVersion(this ComPtr thisVtbl, ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public static unsafe int SetGuid(this ComPtr thisVtbl, Guid* guid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid); + return ret; + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, ref Guid guid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetDocString(this ComPtr thisVtbl, char* szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDoc); + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, ref char szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocPtr = &szDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + } + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocPtr = (byte*) SilkMarshal.StringToPtr(szDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + SilkMarshal.Free((nint)szDocPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetHelpFileName(this ComPtr thisVtbl, char* szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileName); + return ret; + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, ref char szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szHelpFileNamePtr = &szHelpFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szHelpFileNamePtr = (byte*) SilkMarshal.StringToPtr(szHelpFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + SilkMarshal.Free((nint)szHelpFileNamePtr); + return ret; + } + + /// To be documented. + public static int SetHelpContext(this ComPtr thisVtbl, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetLcid(this ComPtr thisVtbl, uint lcid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, lcid); + return ret; + } + + /// To be documented. + public static int SetLibFlags(this ComPtr thisVtbl, uint uLibFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, uLibFlags); + return ret; + } + + /// To be documented. + public static int SaveAllChanges(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public static unsafe int DeleteTypeInfo(this ComPtr thisVtbl, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szName); + return ret; + } + + /// To be documented. + public static int DeleteTypeInfo(this ComPtr thisVtbl, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int DeleteTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int SetCustData(this ComPtr thisVtbl, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static int SetHelpStringContext(this ComPtr thisVtbl, uint dwHelpStringContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, dwHelpStringContext); + return ret; + } + + /// To be documented. + public static unsafe int SetHelpStringDll(this ComPtr thisVtbl, char* szFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileName); + return ret; + } + + /// To be documented. + public static int SetHelpStringDll(this ComPtr thisVtbl, ref char szFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFileNamePtr = &szFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetHelpStringDll(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFileNamePtr = (byte*) SilkMarshal.StringToPtr(szFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileNamePtr); + SilkMarshal.Free((nint)szFileNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, Span szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateTypeInfo(ref szName.GetPinnableReference(), tkind, ppCTInfo); + } + + /// To be documented. + public static int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(ref szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, Span szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateTypeInfo(ref szName.GetPinnableReference(), tkind, ref ppCTInfo); + } + + /// To be documented. + public static int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetName(ref szName.GetPinnableReference()); + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, Span guid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetGuid(ref guid.GetPinnableReference()); + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, Span szDoc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDocString(ref szDoc.GetPinnableReference()); + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, Span szHelpFileName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetHelpFileName(ref szHelpFileName.GetPinnableReference()); + } + + /// To be documented. + public static int DeleteTypeInfo(this ComPtr thisVtbl, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DeleteTypeInfo(ref szName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetCustData(this ComPtr thisVtbl, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int SetCustData(this ComPtr thisVtbl, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetCustData(ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static int SetHelpStringDll(this ComPtr thisVtbl, Span szFileName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetHelpStringDll(ref szFileName.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLibVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLibVtblExtensions.gen.cs new file mode 100644 index 0000000000..53f138ab59 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CreateTypeLibVtblExtensions.gen.cs @@ -0,0 +1,428 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class CreateTypeLibVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfo); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetName(this ComPtr thisVtbl, char* szName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName); + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, ref char szName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static int SetVersion(this ComPtr thisVtbl, ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public static unsafe int SetGuid(this ComPtr thisVtbl, Guid* guid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid); + return ret; + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, ref Guid guid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetDocString(this ComPtr thisVtbl, char* szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDoc); + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, ref char szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szDocPtr = &szDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + } + return ret; + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDoc) + { + var @this = thisVtbl.Handle; + int ret = default; + var szDocPtr = (byte*) SilkMarshal.StringToPtr(szDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + SilkMarshal.Free((nint)szDocPtr); + return ret; + } + + /// To be documented. + public static unsafe int SetHelpFileName(this ComPtr thisVtbl, char* szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileName); + return ret; + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, ref char szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szHelpFileNamePtr = &szHelpFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + } + return ret; + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szHelpFileNamePtr = (byte*) SilkMarshal.StringToPtr(szHelpFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + SilkMarshal.Free((nint)szHelpFileNamePtr); + return ret; + } + + /// To be documented. + public static int SetHelpContext(this ComPtr thisVtbl, uint dwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public static int SetLcid(this ComPtr thisVtbl, uint lcid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, lcid); + return ret; + } + + /// To be documented. + public static int SetLibFlags(this ComPtr thisVtbl, uint uLibFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, uLibFlags); + return ret; + } + + /// To be documented. + public static int SaveAllChanges(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, char* szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, Span szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateTypeInfo(ref szName.GetPinnableReference(), tkind, ppCTInfo); + } + + /// To be documented. + public static int CreateTypeInfo(this ComPtr thisVtbl, ref char szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(ref szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateTypeInfo(this ComPtr thisVtbl, Span szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateTypeInfo(ref szName.GetPinnableReference(), tkind, ref ppCTInfo); + } + + /// To be documented. + public static int CreateTypeInfo(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public static int SetName(this ComPtr thisVtbl, Span szName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetName(ref szName.GetPinnableReference()); + } + + /// To be documented. + public static int SetGuid(this ComPtr thisVtbl, Span guid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetGuid(ref guid.GetPinnableReference()); + } + + /// To be documented. + public static int SetDocString(this ComPtr thisVtbl, Span szDoc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDocString(ref szDoc.GetPinnableReference()); + } + + /// To be documented. + public static int SetHelpFileName(this ComPtr thisVtbl, Span szHelpFileName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetHelpFileName(ref szHelpFileName.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomData.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomData.gen.cs new file mode 100644 index 0000000000..9f17a0f9bd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomData.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCUSTDATA")] + public unsafe partial struct CustomData + { + public CustomData + ( + uint? cCustData = null, + CustomDataItem* prgCustData = null + ) : this() + { + if (cCustData is not null) + { + CCustData = cCustData.Value; + } + + if (prgCustData is not null) + { + PrgCustData = prgCustData; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "cCustData")] + public uint CCustData; + + [NativeName("Type", "LPCUSTDATAITEM")] + [NativeName("Type.Name", "LPCUSTDATAITEM")] + [NativeName("Name", "prgCustData")] + public CustomDataItem* PrgCustData; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomDataItem.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomDataItem.gen.cs new file mode 100644 index 0000000000..d54102c3a0 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/CustomDataItem.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCUSTDATAITEM")] + public unsafe partial struct CustomDataItem + { + public CustomDataItem + ( + Guid? guid = null, + Variant? varValue = null + ) : this() + { + if (guid is not null) + { + Guid = guid.Value; + } + + if (varValue is not null) + { + VarValue = varValue.Value; + } + } + + + [NativeName("Type", "GUID")] + [NativeName("Type.Name", "GUID")] + [NativeName("Name", "guid")] + public Guid Guid; + + [NativeName("Type", "VARIANTARG")] + [NativeName("Type.Name", "VARIANTARG")] + [NativeName("Name", "varValue")] + public Variant VarValue; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DispatchVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DispatchVtblExtensions.gen.cs new file mode 100644 index 0000000000..e116e27bf8 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DispatchVtblExtensions.gen.cs @@ -0,0 +1,1159 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class DispatchVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoCount(this ComPtr thisVtbl, uint* pctinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pctinfo); + return ret; + } + + /// To be documented. + public static int GetTypeInfoCount(this ComPtr thisVtbl, ref uint pctinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pctinfoPtr = &pctinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pctinfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ITypeInfo** ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref ITypeInfo* ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, char** rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNames, cNames, lcid, rgDispId); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, char** rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNames, cNames, lcid, rgDispIdPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, ref char* rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNamesPtr, cNames, lcid, rgDispId); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, ref char* rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNamesPtr, cNames, lcid, rgDispIdPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, char** rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNames, cNames, lcid, rgDispId); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, char** rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNames, cNames, lcid, rgDispIdPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, ref char* rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNamesPtr, cNames, lcid, rgDispId); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, ref char* rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNamesPtr, cNames, lcid, rgDispIdPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetTypeInfoCount(this ComPtr thisVtbl, Span pctinfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoCount(ref pctinfo.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfo(iTInfo, lcid, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, string[] rgszNamesSa, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, string[] rgszNamesSa, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(riid, rgszNames, cNames, lcid, ref rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, char** rgszNames, uint cNames, uint lcid, Span rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(riid, rgszNames, cNames, lcid, ref rgDispId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Guid* riid, ref char* rgszNames, uint cNames, uint lcid, Span rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(riid, ref rgszNames, cNames, lcid, ref rgDispId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, string[] rgszNamesSa, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(ref riid, rgszNames, cNames, lcid, rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Span riid, char** rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref riid.GetPinnableReference(), rgszNames, cNames, lcid, rgDispId); + } + + /// To be documented. + public static int GetIDsOfNames(this ComPtr thisVtbl, ref Guid riid, string[] rgszNamesSa, uint cNames, uint lcid, ref int rgDispId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(ref riid, rgszNames, cNames, lcid, ref rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Span riid, char** rgszNames, uint cNames, uint lcid, Span rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref riid.GetPinnableReference(), rgszNames, cNames, lcid, ref rgDispId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Span riid, ref char* rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref riid.GetPinnableReference(), ref rgszNames, cNames, lcid, rgDispId); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, Span riid, ref char* rgszNames, uint cNames, uint lcid, Span rgDispId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref riid.GetPinnableReference(), ref rgszNames, cNames, lcid, ref rgDispId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDesc.gen.cs new file mode 100644 index 0000000000..fd28b4e80a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDesc.gen.cs @@ -0,0 +1,90 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagELEMDESC")] + public unsafe partial struct ElemDesc + { + public ElemDesc + ( + TypeDesc? tdesc = null, + ElemDescUnion? anonymous = null, + IdlDesc? idldesc = null, + ParamDesc? paramdesc = null + ) : this() + { + if (tdesc is not null) + { + Tdesc = tdesc.Value; + } + + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (idldesc is not null) + { + Idldesc = idldesc.Value; + } + + if (paramdesc is not null) + { + Paramdesc = paramdesc.Value; + } + } + + + [NativeName("Type", "TYPEDESC")] + [NativeName("Type.Name", "TYPEDESC")] + [NativeName("Name", "tdesc")] + public TypeDesc Tdesc; + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_oaidl_L733_C5")] + [NativeName("Name", "anonymous1")] + public ElemDescUnion Anonymous; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IdlDesc Idldesc + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Idldesc; + } +#else + public IdlDesc Idldesc + { + get => Anonymous.Idldesc; + set => Anonymous.Idldesc = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ParamDesc Paramdesc + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Paramdesc; + } +#else + public ParamDesc Paramdesc + { + get => Anonymous.Paramdesc; + set => Anonymous.Paramdesc = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDescUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDescUnion.gen.cs new file mode 100644 index 0000000000..b346849830 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ElemDescUnion.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit)] + [NativeName("Name", "__AnonymousRecord_oaidl_L733_C5")] + public unsafe partial struct ElemDescUnion + { + public ElemDescUnion + ( + IdlDesc? idldesc = null, + ParamDesc? paramdesc = null + ) : this() + { + if (idldesc is not null) + { + Idldesc = idldesc.Value; + } + + if (paramdesc is not null) + { + Paramdesc = paramdesc.Value; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "IDLDESC")] + [NativeName("Type.Name", "IDLDESC")] + [NativeName("Name", "idldesc")] + public IdlDesc Idldesc; + + [FieldOffset(0)] + [NativeName("Type", "PARAMDESC")] + [NativeName("Type.Name", "PARAMDESC")] + [NativeName("Name", "paramdesc")] + public ParamDesc Paramdesc; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionPointsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionPointsVtblExtensions.gen.cs new file mode 100644 index 0000000000..b4e481dae3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionPointsVtblExtensions.gen.cs @@ -0,0 +1,248 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumConnectionPointsVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCP, pcFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCP, pcFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCPPtr, pcFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCPPtr, pcFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint cConnections) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cConnections); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumConnectionPoints** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumConnectionPoints* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumConnectionPoints** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumConnectionPoints**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionsVtblExtensions.gen.cs new file mode 100644 index 0000000000..1760f519ab --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumConnectionsVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumConnectionsVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ConnectData* rgcd, uint* pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcd, pcFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ConnectData* rgcd, ref uint pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcd, pcFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ref ConnectData rgcd, uint* pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ConnectData* rgcdPtr = &rgcd) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcdPtr, pcFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint cConnections, ref ConnectData rgcd, ref uint pcFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ConnectData* rgcdPtr = &rgcd) + { + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcdPtr, pcFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint cConnections) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cConnections); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumConnections** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumConnections* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumConnections** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cConnections, Span rgcd, uint* pcFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint cConnections, Span rgcd, Span pcFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumConnections**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumOleUndoUnitsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumOleUndoUnitsVtblExtensions.gen.cs new file mode 100644 index 0000000000..c7502f18ab --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumOleUndoUnitsVtblExtensions.gen.cs @@ -0,0 +1,248 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumOleUndoUnitsVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgElt, pcEltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcEltFetchedPtr = &pcEltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgElt, pcEltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit** rgEltPtr = &rgElt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgEltPtr, pcEltFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit** rgEltPtr = &rgElt) + { + fixed (uint* pcEltFetchedPtr = &pcEltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgEltPtr, pcEltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint cElt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cElt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumOleUndoUnits** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumOleUndoUnits* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSETSTGVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSETSTGVtblExtensions.gen.cs new file mode 100644 index 0000000000..4eceed6d10 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSETSTGVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumSTATPROPSETSTGVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATPROPSETSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATPROPSETSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumSTATPROPSETSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumSTATPROPSETSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATPROPSETSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumSTATPROPSETSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSTGVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSTGVtblExtensions.gen.cs new file mode 100644 index 0000000000..c734e0bc78 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATPROPSTGVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumSTATPROPSTGVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATPROPSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATPROPSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumSTATPROPSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumSTATPROPSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATPROPSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumSTATPROPSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumVARIANTVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumVARIANTVtblExtensions.gen.cs new file mode 100644 index 0000000000..60ea42cb6b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumVARIANTVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumVARIANTVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Variant* rgVar, uint* pCeltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVar, pCeltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Variant* rgVar, ref uint pCeltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pCeltFetchedPtr = &pCeltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVar, pCeltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Variant rgVar, uint* pCeltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* rgVarPtr = &rgVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVarPtr, pCeltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref Variant rgVar, ref uint pCeltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* rgVarPtr = &rgVar) + { + fixed (uint* pCeltFetchedPtr = &pCeltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVarPtr, pCeltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumVARIANT** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumVARIANT* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumVARIANT** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Variant* rgVar, Span pCeltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgVar, uint* pCeltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgVar, Span pCeltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumVARIANT**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..81f41e4e88 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorInfoVtblExtensions.gen.cs @@ -0,0 +1,278 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ErrorInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetGUID(this ComPtr thisVtbl, Guid* pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGUID); + return ret; + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, ref Guid pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSource(this ComPtr thisVtbl, char** pBstrSource) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrSource); + return ret; + } + + /// To be documented. + public static unsafe int GetSource(this ComPtr thisVtbl, ref char* pBstrSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrSourcePtr = &pBstrSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrSourcePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, char** pBstrDescription) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pBstrDescription); + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, ref char* pBstrDescription) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDescriptionPtr = &pBstrDescription) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pBstrDescriptionPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHelpFile(this ComPtr thisVtbl, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetHelpFile(this ComPtr thisVtbl, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHelpContext(this ComPtr thisVtbl, uint* pdwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pdwHelpContext); + return ret; + } + + /// To be documented. + public static int GetHelpContext(this ComPtr thisVtbl, ref uint pdwHelpContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pdwHelpContextPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, Span pGUID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGUID(ref pGUID.GetPinnableReference()); + } + + /// To be documented. + public static int GetSource(this ComPtr thisVtbl, string[] pBstrSourceSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrSource = (char**) SilkMarshal.StringArrayToPtr(pBstrSourceSa); + var ret = @this->GetSource(pBstrSource); + SilkMarshal.CopyPtrToStringArray((nint) pBstrSource, pBstrSourceSa); + SilkMarshal.Free((nint) pBstrSource); + return ret; + } + + /// To be documented. + public static int GetDescription(this ComPtr thisVtbl, string[] pBstrDescriptionSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDescription = (char**) SilkMarshal.StringArrayToPtr(pBstrDescriptionSa); + var ret = @this->GetDescription(pBstrDescription); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDescription, pBstrDescriptionSa); + SilkMarshal.Free((nint) pBstrDescription); + return ret; + } + + /// To be documented. + public static int GetHelpFile(this ComPtr thisVtbl, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetHelpFile(pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static int GetHelpContext(this ComPtr thisVtbl, Span pdwHelpContext) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHelpContext(ref pdwHelpContext.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorLogVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorLogVtblExtensions.gen.cs new file mode 100644 index 0000000000..98db50b808 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ErrorLogVtblExtensions.gen.cs @@ -0,0 +1,226 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ErrorLogVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pExcepInfo); + return ret; + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pExcepInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfo); + } + return ret; + } + + /// To be documented. + public static int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfo); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfoPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pExcepInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddError(pszPropName, ref pExcepInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddError(in pszPropName.GetPinnableReference(), pExcepInfo); + } + + /// To be documented. + public static int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pExcepInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddError(in pszPropName.GetPinnableReference(), ref pExcepInfo.GetPinnableReference()); + } + + /// To be documented. + public static int AddError(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pExcepInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddError(pszPropName, ref pExcepInfo.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ExtentInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ExtentInfo.gen.cs new file mode 100644 index 0000000000..2f2934cb51 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ExtentInfo.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagExtentInfo")] + public unsafe partial struct ExtentInfo + { + public ExtentInfo + ( + uint? cb = null, + uint? dwExtentMode = null, + Silk.NET.Maths.Vector2D? sizelProposed = null + ) : this() + { + if (cb is not null) + { + Cb = cb.Value; + } + + if (dwExtentMode is not null) + { + DwExtentMode = dwExtentMode.Value; + } + + if (sizelProposed is not null) + { + SizelProposed = sizelProposed.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cb")] + public uint Cb; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwExtentMode")] + public uint DwExtentMode; + + [NativeName("Type", "SIZEL")] + [NativeName("Type.Name", "SIZEL")] + [NativeName("Name", "sizelProposed")] + public Silk.NET.Maths.Vector2D SizelProposed; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/FuncDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/FuncDesc.gen.cs new file mode 100644 index 0000000000..1da709538f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/FuncDesc.gen.cs @@ -0,0 +1,160 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagFUNCDESC")] + public unsafe partial struct FuncDesc + { + public FuncDesc + ( + int? memid = null, + int* lprgscode = null, + ElemDesc* lprgelemdescParam = null, + FuncKind? funckind = null, + InvokeKind? invkind = null, + CallConv? callconv = null, + short? cParams = null, + short? cParamsOpt = null, + short? oVft = null, + short? cScodes = null, + ElemDesc? elemdescFunc = null, + ushort? wFuncFlags = null + ) : this() + { + if (memid is not null) + { + Memid = memid.Value; + } + + if (lprgscode is not null) + { + Lprgscode = lprgscode; + } + + if (lprgelemdescParam is not null) + { + LprgelemdescParam = lprgelemdescParam; + } + + if (funckind is not null) + { + Funckind = funckind.Value; + } + + if (invkind is not null) + { + Invkind = invkind.Value; + } + + if (callconv is not null) + { + Callconv = callconv.Value; + } + + if (cParams is not null) + { + CParams = cParams.Value; + } + + if (cParamsOpt is not null) + { + CParamsOpt = cParamsOpt.Value; + } + + if (oVft is not null) + { + OVft = oVft.Value; + } + + if (cScodes is not null) + { + CScodes = cScodes.Value; + } + + if (elemdescFunc is not null) + { + ElemdescFunc = elemdescFunc.Value; + } + + if (wFuncFlags is not null) + { + WFuncFlags = wFuncFlags.Value; + } + } + + + [NativeName("Type", "MEMBERID")] + [NativeName("Type.Name", "MEMBERID")] + [NativeName("Name", "memid")] + public int Memid; + + [NativeName("Type", "SCODE *")] + [NativeName("Type.Name", "SCODE *")] + [NativeName("Name", "lprgscode")] + public int* Lprgscode; + + [NativeName("Type", "ELEMDESC *")] + [NativeName("Type.Name", "ELEMDESC *")] + [NativeName("Name", "lprgelemdescParam")] + public ElemDesc* LprgelemdescParam; + + [NativeName("Type", "FUNCKIND")] + [NativeName("Type.Name", "FUNCKIND")] + [NativeName("Name", "funckind")] + public FuncKind Funckind; + + [NativeName("Type", "INVOKEKIND")] + [NativeName("Type.Name", "INVOKEKIND")] + [NativeName("Name", "invkind")] + public InvokeKind Invkind; + + [NativeName("Type", "CALLCONV")] + [NativeName("Type.Name", "CALLCONV")] + [NativeName("Name", "callconv")] + public CallConv Callconv; + + [NativeName("Type", "SHORT")] + [NativeName("Type.Name", "SHORT")] + [NativeName("Name", "cParams")] + public short CParams; + + [NativeName("Type", "SHORT")] + [NativeName("Type.Name", "SHORT")] + [NativeName("Name", "cParamsOpt")] + public short CParamsOpt; + + [NativeName("Type", "SHORT")] + [NativeName("Type.Name", "SHORT")] + [NativeName("Name", "oVft")] + public short OVft; + + [NativeName("Type", "SHORT")] + [NativeName("Type.Name", "SHORT")] + [NativeName("Name", "cScodes")] + public short CScodes; + + [NativeName("Type", "ELEMDESC")] + [NativeName("Type.Name", "ELEMDESC")] + [NativeName("Name", "elemdescFunc")] + public ElemDesc ElemdescFunc; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wFuncFlags")] + public ushort WFuncFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSinkEx.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSinkEx.gen.cs new file mode 100644 index 0000000000..a6e5b5b7fb --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSinkEx.gen.cs @@ -0,0 +1,228 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("3af24290-0c96-11ce-a0cf-00aa00600ab8")] + [NativeName("Name", "IAdviseSinkEx")] + public unsafe partial struct IAdviseSinkEx : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3af24290-0c96-11ce-a0cf-00aa00600ab8"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IAdviseSink(IAdviseSinkEx val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IAdviseSinkEx val) + => Unsafe.As(ref val); + + public IAdviseSinkEx + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, STGMEDIUM* pStgmed) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public readonly unsafe void OnDataChange(ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public readonly void OnDataChange(ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public readonly void OnViewChange(uint dwAspect, int lindex) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public readonly unsafe void OnRename(IMoniker* pmk) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public readonly void OnRename(ref IMoniker pmk) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void OnSave() + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public readonly void OnClose() + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public readonly void OnViewStatusChange(uint dwViewStatus) + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwViewStatus); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly void OnRename(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSinkEx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPoint.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPoint.gen.cs new file mode 100644 index 0000000000..dbee70487b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPoint.gen.cs @@ -0,0 +1,284 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b286-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "IConnectionPoint")] + public unsafe partial struct IConnectionPoint : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b286-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IConnectionPoint val) + => Unsafe.As(ref val); + + public IConnectionPoint + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetConnectionInterface(Guid* pIID) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pIID); + return ret; + } + + /// To be documented. + public readonly int GetConnectionInterface(ref Guid pIID) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pIIDPtr = &pIID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pIIDPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetConnectionPointContainer(IConnectionPointContainer** ppCPC) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppCPC); + return ret; + } + + /// To be documented. + public readonly unsafe int GetConnectionPointContainer(ref IConnectionPointContainer* ppCPC) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IConnectionPointContainer** ppCPCPtr = &ppCPC) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppCPCPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(Silk.NET.Core.Native.IUnknown* pUnkSink, uint* pdwCookie) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSink, pdwCookie); + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(Silk.NET.Core.Native.IUnknown* pUnkSink, ref uint pdwCookie) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwCookiePtr = &pdwCookie) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSink, pdwCookiePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref Silk.NET.Core.Native.IUnknown pUnkSink, uint* pdwCookie) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSinkPtr = &pUnkSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSinkPtr, pdwCookie); + } + return ret; + } + + /// To be documented. + public readonly int Advise(ref Silk.NET.Core.Native.IUnknown pUnkSink, ref uint pdwCookie) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSinkPtr = &pUnkSink) + { + fixed (uint* pdwCookiePtr = &pdwCookie) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUnkSinkPtr, pdwCookiePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Unadvise(uint dwCookie) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwCookie); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumConnections(IEnumConnections** ppEnum) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumConnections(ref IEnumConnections* ppEnum) + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumConnections** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetConnectionPointContainer(ref ComPtr ppCPC) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetConnectionPointContainer((IConnectionPointContainer**) ppCPC.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pUnkSink, uint* pdwCookie) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((Silk.NET.Core.Native.IUnknown*) pUnkSink.Handle, pdwCookie); + } + + /// To be documented. + public readonly int Advise(ComPtr pUnkSink, ref uint pdwCookie) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((Silk.NET.Core.Native.IUnknown*) pUnkSink.Handle, ref pdwCookie); + } + + /// To be documented. + public readonly int EnumConnections(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumConnections((IEnumConnections**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IConnectionPoint*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPointContainer.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPointContainer.gen.cs new file mode 100644 index 0000000000..92a10bc406 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IConnectionPointContainer.gen.cs @@ -0,0 +1,235 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b284-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "IConnectionPointContainer")] + public unsafe partial struct IConnectionPointContainer : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b284-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IConnectionPointContainer val) + => Unsafe.As(ref val); + + public IConnectionPointContainer + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumConnectionPoints(IEnumConnectionPoints** ppEnum) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumConnectionPoints(ref IEnumConnectionPoints* ppEnum) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumConnectionPoints** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindConnectionPoint(Guid* riid, IConnectionPoint** ppCP) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppCP); + return ret; + } + + /// To be documented. + public readonly unsafe int FindConnectionPoint(Guid* riid, ref IConnectionPoint* ppCP) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppCPPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindConnectionPoint(ref Guid riid, IConnectionPoint** ppCP) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppCP); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindConnectionPoint(ref Guid riid, ref IConnectionPoint* ppCP) + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppCPPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumConnectionPoints(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumConnectionPoints((IEnumConnectionPoints**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly int FindConnectionPoint(out ComPtr ppCP) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppCP = default; + return @this->FindConnectionPoint(SilkMarshal.GuidPtrOf(), (IConnectionPoint**) ppCP.GetAddressOf()); + } + + /// To be documented. + public readonly int FindConnectionPoint(ref Guid riid, ref ComPtr ppCP) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindConnectionPoint(ref riid, (IConnectionPoint**) ppCP.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr FindConnectionPoint() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IConnectionPointContainer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->FindConnectionPoint(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateErrorInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateErrorInfo.gen.cs new file mode 100644 index 0000000000..e8ba65500a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateErrorInfo.gen.cs @@ -0,0 +1,258 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("22f03340-547d-101b-8e65-08002b2bd119")] + [NativeName("Name", "ICreateErrorInfo")] + public unsafe partial struct ICreateErrorInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("22f03340-547d-101b-8e65-08002b2bd119"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ICreateErrorInfo val) + => Unsafe.As(ref val); + + public ICreateErrorInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetGUID(Guid* rguid) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguid); + return ret; + } + + /// To be documented. + public readonly int SetGUID(ref Guid rguid) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidPtr = &rguid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetSource(char* szSource) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSource); + return ret; + } + + /// To be documented. + public readonly int SetSource(ref char szSource) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szSourcePtr = &szSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSourcePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSource([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szSource) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szSourcePtr = (byte*) SilkMarshal.StringToPtr(szSource, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szSourcePtr); + SilkMarshal.Free((nint)szSourcePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetDescription(char* szDescription) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescription); + return ret; + } + + /// To be documented. + public readonly int SetDescription(ref char szDescription) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDescriptionPtr = &szDescription) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescriptionPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetDescription([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDescription) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDescriptionPtr = (byte*) SilkMarshal.StringToPtr(szDescription, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, szDescriptionPtr); + SilkMarshal.Free((nint)szDescriptionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetHelpFile(char* szHelpFile) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFile); + return ret; + } + + /// To be documented. + public readonly int SetHelpFile(ref char szHelpFile) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szHelpFilePtr = &szHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetHelpFile([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFile) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szHelpFilePtr = (byte*) SilkMarshal.StringToPtr(szHelpFile, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, szHelpFilePtr); + SilkMarshal.Free((nint)szHelpFilePtr); + return ret; + } + + /// To be documented. + public readonly int SetHelpContext(uint dwHelpContext) + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo.gen.cs new file mode 100644 index 0000000000..56cf9b439e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo.gen.cs @@ -0,0 +1,718 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020405-0000-0000-c000-000000000046")] + [NativeName("Name", "ICreateTypeInfo")] + public unsafe partial struct ICreateTypeInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020405-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ICreateTypeInfo val) + => Unsafe.As(ref val); + + public ICreateTypeInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetGuid(Guid* guid) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guid); + return ret; + } + + /// To be documented. + public readonly int SetGuid(ref Guid guid) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetTypeFlags(uint uTypeFlags) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, uTypeFlags); + return ret; + } + + /// To be documented. + public readonly unsafe int SetDocString(char* pStrDoc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDoc); + return ret; + } + + /// To be documented. + public readonly int SetDocString(ref char pStrDoc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrDocPtr = &pStrDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetDocString([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrDoc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrDocPtr = (byte*) SilkMarshal.StringToPtr(pStrDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + SilkMarshal.Free((nint)pStrDocPtr); + return ret; + } + + /// To be documented. + public readonly int SetHelpContext(uint dwHelpContext) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetVersion(ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ITypeInfo* pTInfo, uint* phRefType) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefType); + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ITypeInfo* pTInfo, ref uint phRefType) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ref ITypeInfo pTInfo, uint* phRefType) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefType); + } + return ret; + } + + /// To be documented. + public readonly int AddRefTypeInfo(ref ITypeInfo pTInfo, ref uint phRefType) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefTypePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddFuncDesc(uint index, FuncDesc* pFuncDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDesc); + return ret; + } + + /// To be documented. + public readonly int AddFuncDesc(uint index, ref FuncDesc pFuncDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDescPtr); + } + return ret; + } + + /// To be documented. + public readonly int AddImplType(uint index, uint hRefType) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, index, hRefType); + return ret; + } + + /// To be documented. + public readonly int SetImplTypeFlags(uint index, int implTypeFlags) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, index, implTypeFlags); + return ret; + } + + /// To be documented. + public readonly int SetAlignment(ushort cbAlignment) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, cbAlignment); + return ret; + } + + /// To be documented. + public readonly unsafe int SetSchema(char* pStrSchema) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchema); + return ret; + } + + /// To be documented. + public readonly int SetSchema(ref char pStrSchema) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrSchemaPtr = &pStrSchema) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSchema([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrSchema) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrSchemaPtr = (byte*) SilkMarshal.StringToPtr(pStrSchema, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + SilkMarshal.Free((nint)pStrSchemaPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AddVarDesc(uint index, VarDesc* pVarDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDesc); + return ret; + } + + /// To be documented. + public readonly int AddVarDesc(uint index, ref VarDesc pVarDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncAndParamNames(uint index, char** rgszNames, uint cNames) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNames, cNames); + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncAndParamNames(uint index, ref char* rgszNames, uint cNames) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNamesPtr, cNames); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarName(uint index, char* szName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szName); + return ret; + } + + /// To be documented. + public readonly int SetVarName(uint index, ref char szName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetVarName(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetTypeDescAlias(TypeDesc* pTDescAlias) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAlias); + return ret; + } + + /// To be documented. + public readonly int SetTypeDescAlias(ref TypeDesc pTDescAlias) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeDesc* pTDescAliasPtr = &pTDescAlias) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAliasPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcName); + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, ref char szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + } + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, ref char szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, ref char szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncDocString(uint index, char* szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public readonly int SetFuncDocString(uint index, ref char szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetFuncDocString(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarDocString(uint index, char* szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public readonly int SetVarDocString(uint index, ref char szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetVarDocString(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public readonly int SetFuncHelpContext(uint index, uint dwHelpContext) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetVarHelpContext(uint index, uint dwHelpContext) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly unsafe int SetMops(uint index, char* bstrMops) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMops); + return ret; + } + + /// To be documented. + public readonly int SetMops(uint index, ref char bstrMops) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* bstrMopsPtr = &bstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetMops(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrMops) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var bstrMopsPtr = (byte*) SilkMarshal.StringToPtr(bstrMops, NativeStringEncoding.BStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + SilkMarshal.Free((nint)bstrMopsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetTypeIdldesc(IdlDesc* pIdlDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDesc); + return ret; + } + + /// To be documented. + public readonly int SetTypeIdldesc(ref IdlDesc pIdlDesc) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IdlDesc* pIdlDescPtr = &pIdlDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDescPtr); + } + return ret; + } + + /// To be documented. + public readonly int LayOut() + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ComPtr pTInfo, uint* phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, phRefType); + } + + /// To be documented. + public readonly int AddRefTypeInfo(ComPtr pTInfo, ref uint phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, ref phRefType); + } + + /// To be documented. + public readonly int SetFuncAndParamNames(uint index, string[] rgszNamesSa, uint cNames) + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->SetFuncAndParamNames(index, rgszNames, cNames); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo2.gen.cs new file mode 100644 index 0000000000..2b8f90f3be --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeInfo2.gen.cs @@ -0,0 +1,1074 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0002040e-0000-0000-c000-000000000046")] + [NativeName("Name", "ICreateTypeInfo2")] + public unsafe partial struct ICreateTypeInfo2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0002040e-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator ICreateTypeInfo(ICreateTypeInfo2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ICreateTypeInfo2 val) + => Unsafe.As(ref val); + + public ICreateTypeInfo2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetGuid(Guid* guid) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guid); + return ret; + } + + /// To be documented. + public readonly int SetGuid(ref Guid guid) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetTypeFlags(uint uTypeFlags) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, uTypeFlags); + return ret; + } + + /// To be documented. + public readonly unsafe int SetDocString(char* pStrDoc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDoc); + return ret; + } + + /// To be documented. + public readonly int SetDocString(ref char pStrDoc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrDocPtr = &pStrDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetDocString([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrDoc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrDocPtr = (byte*) SilkMarshal.StringToPtr(pStrDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStrDocPtr); + SilkMarshal.Free((nint)pStrDocPtr); + return ret; + } + + /// To be documented. + public readonly int SetHelpContext(uint dwHelpContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetVersion(ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ITypeInfo* pTInfo, uint* phRefType) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefType); + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ITypeInfo* pTInfo, ref uint phRefType) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfo, phRefTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ref ITypeInfo pTInfo, uint* phRefType) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefType); + } + return ret; + } + + /// To be documented. + public readonly int AddRefTypeInfo(ref ITypeInfo pTInfo, ref uint phRefType) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoPtr = &pTInfo) + { + fixed (uint* phRefTypePtr = &phRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pTInfoPtr, phRefTypePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddFuncDesc(uint index, FuncDesc* pFuncDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDesc); + return ret; + } + + /// To be documented. + public readonly int AddFuncDesc(uint index, ref FuncDesc pFuncDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pFuncDescPtr); + } + return ret; + } + + /// To be documented. + public readonly int AddImplType(uint index, uint hRefType) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, index, hRefType); + return ret; + } + + /// To be documented. + public readonly int SetImplTypeFlags(uint index, int implTypeFlags) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, index, implTypeFlags); + return ret; + } + + /// To be documented. + public readonly int SetAlignment(ushort cbAlignment) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, cbAlignment); + return ret; + } + + /// To be documented. + public readonly unsafe int SetSchema(char* pStrSchema) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchema); + return ret; + } + + /// To be documented. + public readonly int SetSchema(ref char pStrSchema) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrSchemaPtr = &pStrSchema) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSchema([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrSchema) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrSchemaPtr = (byte*) SilkMarshal.StringToPtr(pStrSchema, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pStrSchemaPtr); + SilkMarshal.Free((nint)pStrSchemaPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AddVarDesc(uint index, VarDesc* pVarDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDesc); + return ret; + } + + /// To be documented. + public readonly int AddVarDesc(uint index, ref VarDesc pVarDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, index, pVarDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncAndParamNames(uint index, char** rgszNames, uint cNames) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNames, cNames); + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncAndParamNames(uint index, ref char* rgszNames, uint cNames) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, rgszNamesPtr, cNames); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarName(uint index, char* szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szName); + return ret; + } + + /// To be documented. + public readonly int SetVarName(uint index, ref char szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetVarName(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, index, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetTypeDescAlias(TypeDesc* pTDescAlias) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAlias); + return ret; + } + + /// To be documented. + public readonly int SetTypeDescAlias(ref TypeDesc pTDescAlias) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeDesc* pTDescAliasPtr = &pTDescAlias) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pTDescAliasPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcName); + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, char* szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllName, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, ref char szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + } + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, ref char szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, ref char szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDllNamePtr = &szDllName) + { + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, char* szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcName); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, ref char szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + fixed (char* szProcNamePtr = &szProcName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + } + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly int DefineFuncAsDllEntry(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDllName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szProcName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDllNamePtr = (byte*) SilkMarshal.StringToPtr(szDllName, NativeStringEncoding.UTF8); + var szProcNamePtr = (byte*) SilkMarshal.StringToPtr(szProcName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, index, szDllNamePtr, szProcNamePtr); + SilkMarshal.Free((nint)szProcNamePtr); + SilkMarshal.Free((nint)szDllNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncDocString(uint index, char* szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public readonly int SetFuncDocString(uint index, ref char szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetFuncDocString(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarDocString(uint index, char* szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocString); + return ret; + } + + /// To be documented. + public readonly int SetVarDocString(uint index, ref char szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocStringPtr = &szDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetVarDocString(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDocString) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocStringPtr = (byte*) SilkMarshal.StringToPtr(szDocString, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, index, szDocStringPtr); + SilkMarshal.Free((nint)szDocStringPtr); + return ret; + } + + /// To be documented. + public readonly int SetFuncHelpContext(uint index, uint dwHelpContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetVarHelpContext(uint index, uint dwHelpContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, index, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly unsafe int SetMops(uint index, char* bstrMops) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMops); + return ret; + } + + /// To be documented. + public readonly int SetMops(uint index, ref char bstrMops) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* bstrMopsPtr = &bstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetMops(uint index, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrMops) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var bstrMopsPtr = (byte*) SilkMarshal.StringToPtr(bstrMops, NativeStringEncoding.BStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, index, bstrMopsPtr); + SilkMarshal.Free((nint)bstrMopsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetTypeIdldesc(IdlDesc* pIdlDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDesc); + return ret; + } + + /// To be documented. + public readonly int SetTypeIdldesc(ref IdlDesc pIdlDesc) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IdlDesc* pIdlDescPtr = &pIdlDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, pIdlDescPtr); + } + return ret; + } + + /// To be documented. + public readonly int LayOut() + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this); + return ret; + } + + /// To be documented. + public readonly int DeleteFuncDesc(uint index) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, index); + return ret; + } + + /// To be documented. + public readonly int DeleteFuncDescByMemId(int memid, InvokeKind invKind) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, memid, invKind); + return ret; + } + + /// To be documented. + public readonly int DeleteVarDesc(uint index) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, index); + return ret; + } + + /// To be documented. + public readonly int DeleteVarDescByMemId(int memid) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, memid); + return ret; + } + + /// To be documented. + public readonly int DeleteImplType(uint index) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index); + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetCustData(ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetFuncCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetFuncCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetParamCustData(uint indexFunc, uint indexParam, Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetParamCustData(uint indexFunc, uint indexParam, Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetParamCustData(uint indexFunc, uint indexParam, ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetParamCustData(uint indexFunc, uint indexParam, ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, indexFunc, indexParam, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetVarCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetVarCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetImplTypeCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetImplTypeCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetImplTypeCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetImplTypeCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int SetHelpStringContext(uint dwHelpStringContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, dwHelpStringContext); + return ret; + } + + /// To be documented. + public readonly int SetFuncHelpStringContext(uint index, uint dwHelpStringContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[37])(@this, index, dwHelpStringContext); + return ret; + } + + /// To be documented. + public readonly int SetVarHelpStringContext(uint index, uint dwHelpStringContext) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[38])(@this, index, dwHelpStringContext); + return ret; + } + + /// To be documented. + public readonly int Invalidate() + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[39])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetName(char* szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szName); + return ret; + } + + /// To be documented. + public readonly int SetName(ref char szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[40])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int AddRefTypeInfo(ComPtr pTInfo, uint* phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, phRefType); + } + + /// To be documented. + public readonly int AddRefTypeInfo(ComPtr pTInfo, ref uint phRefType) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AddRefTypeInfo((ITypeInfo*) pTInfo.Handle, ref phRefType); + } + + /// To be documented. + public readonly int SetFuncAndParamNames(uint index, string[] rgszNamesSa, uint cNames) + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->SetFuncAndParamNames(index, rgszNames, cNames); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib.gen.cs new file mode 100644 index 0000000000..e2328fd8aa --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib.gen.cs @@ -0,0 +1,391 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020406-0000-0000-c000-000000000046")] + [NativeName("Name", "ICreateTypeLib")] + public unsafe partial struct ICreateTypeLib : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020406-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ICreateTypeLib val) + => Unsafe.As(ref val); + + public ICreateTypeLib + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(ref char szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(ref char szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetName(char* szName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName); + return ret; + } + + /// To be documented. + public readonly int SetName(ref char szName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetVersion(ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public readonly unsafe int SetGuid(Guid* guid) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid); + return ret; + } + + /// To be documented. + public readonly int SetGuid(ref Guid guid) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetDocString(char* szDoc) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDoc); + return ret; + } + + /// To be documented. + public readonly int SetDocString(ref char szDoc) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocPtr = &szDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetDocString([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDoc) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocPtr = (byte*) SilkMarshal.StringToPtr(szDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + SilkMarshal.Free((nint)szDocPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetHelpFileName(char* szHelpFileName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileName); + return ret; + } + + /// To be documented. + public readonly int SetHelpFileName(ref char szHelpFileName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szHelpFileNamePtr = &szHelpFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetHelpFileName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFileName) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szHelpFileNamePtr = (byte*) SilkMarshal.StringToPtr(szHelpFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + SilkMarshal.Free((nint)szHelpFileNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetHelpContext(uint dwHelpContext) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetLcid(uint lcid) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, lcid); + return ret; + } + + /// To be documented. + public readonly int SetLibFlags(uint uLibFlags) + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, uLibFlags); + return ret; + } + + /// To be documented. + public readonly int SaveAllChanges() + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateTypeInfo(ref char szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(ref szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib2.gen.cs new file mode 100644 index 0000000000..e5dbd5e24d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ICreateTypeLib2.gen.cs @@ -0,0 +1,515 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0002040f-0000-0000-c000-000000000046")] + [NativeName("Name", "ICreateTypeLib2")] + public unsafe partial struct ICreateTypeLib2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0002040f-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator ICreateTypeLib(ICreateTypeLib2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ICreateTypeLib2 val) + => Unsafe.As(ref val); + + public ICreateTypeLib2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, tkind, ppCTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(ref char szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(ref char szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ICreateTypeInfo** ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfo); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ICreateTypeInfo* ppCTInfo) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ICreateTypeInfo** ppCTInfoPtr = &ppCTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, tkind, ppCTInfoPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetName(char* szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName); + return ret; + } + + /// To be documented. + public readonly int SetName(ref char szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetVersion(ushort wMajorVerNum, ushort wMinorVerNum) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, wMajorVerNum, wMinorVerNum); + return ret; + } + + /// To be documented. + public readonly unsafe int SetGuid(Guid* guid) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid); + return ret; + } + + /// To be documented. + public readonly int SetGuid(ref Guid guid) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetDocString(char* szDoc) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDoc); + return ret; + } + + /// To be documented. + public readonly int SetDocString(ref char szDoc) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szDocPtr = &szDoc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetDocString([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szDoc) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szDocPtr = (byte*) SilkMarshal.StringToPtr(szDoc, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, szDocPtr); + SilkMarshal.Free((nint)szDocPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetHelpFileName(char* szHelpFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileName); + return ret; + } + + /// To be documented. + public readonly int SetHelpFileName(ref char szHelpFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szHelpFileNamePtr = &szHelpFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetHelpFileName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szHelpFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szHelpFileNamePtr = (byte*) SilkMarshal.StringToPtr(szHelpFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, szHelpFileNamePtr); + SilkMarshal.Free((nint)szHelpFileNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetHelpContext(uint dwHelpContext) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, dwHelpContext); + return ret; + } + + /// To be documented. + public readonly int SetLcid(uint lcid) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, lcid); + return ret; + } + + /// To be documented. + public readonly int SetLibFlags(uint uLibFlags) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, uLibFlags); + return ret; + } + + /// To be documented. + public readonly int SaveAllChanges() + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int DeleteTypeInfo(char* szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szName); + return ret; + } + + /// To be documented. + public readonly int DeleteTypeInfo(ref char szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int DeleteTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, szNamePtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(Guid* guid, Variant* pVarVal) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(Guid* guid, ref Variant pVarVal) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetCustData(ref Guid guid, Variant* pVarVal) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int SetCustData(ref Guid guid, ref Variant pVarVal) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int SetHelpStringContext(uint dwHelpStringContext) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, dwHelpStringContext); + return ret; + } + + /// To be documented. + public readonly unsafe int SetHelpStringDll(char* szFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileName); + return ret; + } + + /// To be documented. + public readonly int SetHelpStringDll(ref char szFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFileNamePtr = &szFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetHelpStringDll([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFileName) + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFileNamePtr = (byte*) SilkMarshal.StringToPtr(szFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, szFileNamePtr); + SilkMarshal.Free((nint)szFileNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateTypeInfo(char* szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateTypeInfo(ref char szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(ref szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateTypeInfo([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, TypeKind tkind, ref ComPtr ppCTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateTypeInfo(szName, tkind, (ICreateTypeInfo**) ppCTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ICreateTypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDispatch.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDispatch.gen.cs new file mode 100644 index 0000000000..4bce76398b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDispatch.gen.cs @@ -0,0 +1,866 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020400-0000-0000-c000-000000000046")] + [NativeName("Name", "IDispatch")] + public unsafe partial struct IDispatch : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020400-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IDispatch val) + => Unsafe.As(ref val); + + public IDispatch + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoCount(uint* pctinfo) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pctinfo); + return ret; + } + + /// To be documented. + public readonly int GetTypeInfoCount(ref uint pctinfo) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pctinfoPtr = &pctinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pctinfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, ITypeInfo** ppTInfo) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, ref ITypeInfo* ppTInfo) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, char** rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNames, cNames, lcid, rgDispId); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, char** rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNames, cNames, lcid, rgDispIdPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, ref char* rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNamesPtr, cNames, lcid, rgDispId); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, ref char* rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riid, rgszNamesPtr, cNames, lcid, rgDispIdPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref Guid riid, char** rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNames, cNames, lcid, rgDispId); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref Guid riid, char** rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNames, cNames, lcid, rgDispIdPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref Guid riid, ref char* rgszNames, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNamesPtr, cNames, lcid, rgDispId); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref Guid riid, ref char* rgszNames, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* rgDispIdPtr = &rgDispId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, riidPtr, rgszNamesPtr, cNames, lcid, rgDispIdPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riid, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispIdMember, riidPtr, lcid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfo(uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfo(iTInfo, lcid, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, string[] rgszNamesSa, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(Guid* riid, string[] rgszNamesSa, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(riid, rgszNames, cNames, lcid, ref rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref Guid riid, string[] rgszNamesSa, uint cNames, uint lcid, int* rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(ref riid, rgszNames, cNames, lcid, rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly int GetIDsOfNames(ref Guid riid, string[] rgszNamesSa, uint cNames, uint lcid, ref int rgDispId) + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(ref riid, rgszNames, cNames, lcid, ref rgDispId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IDispatch*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnectionPoints.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnectionPoints.gen.cs new file mode 100644 index 0000000000..52ee052f32 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnectionPoints.gen.cs @@ -0,0 +1,243 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b285-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "IEnumConnectionPoints")] + public unsafe partial struct IEnumConnectionPoints : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b285-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumConnectionPoints val) + => Unsafe.As(ref val); + + public IEnumConnectionPoints + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, IConnectionPoint** ppCP, uint* pcFetched) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCP, pcFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCP, pcFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCPPtr, pcFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IConnectionPoint** ppCPPtr = &ppCP) + { + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, ppCPPtr, pcFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint cConnections) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cConnections); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumConnectionPoints** ppEnum) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumConnectionPoints* ppEnum) + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumConnectionPoints** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); + } + + /// To be documented. + public readonly int Next(uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumConnectionPoints**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumConnectionPoints*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnections.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnections.gen.cs new file mode 100644 index 0000000000..bd430ff146 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumConnections.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b287-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "IEnumConnections")] + public unsafe partial struct IEnumConnections : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b287-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumConnections val) + => Unsafe.As(ref val); + + public IEnumConnections + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ConnectData* rgcd, uint* pcFetched) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcd, pcFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ConnectData* rgcd, ref uint pcFetched) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcd, pcFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cConnections, ref ConnectData rgcd, uint* pcFetched) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ConnectData* rgcdPtr = &rgcd) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcdPtr, pcFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint cConnections, ref ConnectData rgcd, ref uint pcFetched) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ConnectData* rgcdPtr = &rgcd) + { + fixed (uint* pcFetchedPtr = &pcFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cConnections, rgcdPtr, pcFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint cConnections) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cConnections); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumConnections** ppEnum) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumConnections* ppEnum) + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumConnections** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumConnections**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumConnections*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumOleUndoUnits.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumOleUndoUnits.gen.cs new file mode 100644 index 0000000000..671785c5e7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumOleUndoUnits.gen.cs @@ -0,0 +1,243 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b3e7c340-ef97-11ce-9bc9-00aa00608e01")] + [NativeName("Name", "IEnumOleUndoUnits")] + public unsafe partial struct IEnumOleUndoUnits : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b3e7c340-ef97-11ce-9bc9-00aa00608e01"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumOleUndoUnits val) + => Unsafe.As(ref val); + + public IEnumOleUndoUnits + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgElt, pcEltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcEltFetchedPtr = &pcEltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgElt, pcEltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit** rgEltPtr = &rgElt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgEltPtr, pcEltFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit** rgEltPtr = &rgElt) + { + fixed (uint* pcEltFetchedPtr = &pcEltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cElt, rgEltPtr, pcEltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint cElt) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cElt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumOleUndoUnits** ppEnum) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumOleUndoUnits* ppEnum) + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Next(uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); + } + + /// To be documented. + public readonly int Next(uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumOleUndoUnits*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSETSTG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSETSTG.gen.cs new file mode 100644 index 0000000000..b4cf7ee1e9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSETSTG.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000013b-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumSTATPROPSETSTG")] + public unsafe partial struct IEnumSTATPROPSETSTG : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000013b-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumSTATPROPSETSTG val) + => Unsafe.As(ref val); + + public IEnumSTATPROPSETSTG + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATPROPSETSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATPROPSETSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumSTATPROPSETSTG** ppenum) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumSTATPROPSETSTG* ppenum) + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATPROPSETSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumSTATPROPSETSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATPROPSETSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSTG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSTG.gen.cs new file mode 100644 index 0000000000..9208b127d6 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATPROPSTG.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000139-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumSTATPROPSTG")] + public unsafe partial struct IEnumSTATPROPSTG : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000139-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumSTATPROPSTG val) + => Unsafe.As(ref val); + + public IEnumSTATPROPSTG + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATPROPSTG* rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATPROPSTG* rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref STATPROPSTG rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATPROPSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATPROPSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumSTATPROPSTG** ppenum) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumSTATPROPSTG* ppenum) + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATPROPSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumSTATPROPSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATPROPSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumVARIANT.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumVARIANT.gen.cs new file mode 100644 index 0000000000..a19f23632c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumVARIANT.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020404-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumVARIANT")] + public unsafe partial struct IEnumVARIANT : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020404-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumVARIANT val) + => Unsafe.As(ref val); + + public IEnumVARIANT + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, Variant* rgVar, uint* pCeltFetched) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVar, pCeltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, Variant* rgVar, ref uint pCeltFetched) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pCeltFetchedPtr = &pCeltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVar, pCeltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref Variant rgVar, uint* pCeltFetched) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* rgVarPtr = &rgVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVarPtr, pCeltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref Variant rgVar, ref uint pCeltFetched) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* rgVarPtr = &rgVar) + { + fixed (uint* pCeltFetchedPtr = &pCeltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgVarPtr, pCeltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumVARIANT** ppEnum) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumVARIANT* ppEnum) + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumVARIANT** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumVARIANT**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumVARIANT*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorInfo.gen.cs new file mode 100644 index 0000000000..5c313375e6 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorInfo.gen.cs @@ -0,0 +1,273 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("1cf2b120-547d-101b-8e65-08002b2bd119")] + [NativeName("Name", "IErrorInfo")] + public unsafe partial struct IErrorInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("1cf2b120-547d-101b-8e65-08002b2bd119"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IErrorInfo val) + => Unsafe.As(ref val); + + public IErrorInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetGUID(Guid* pGUID) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGUID); + return ret; + } + + /// To be documented. + public readonly int GetGUID(ref Guid pGUID) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSource(char** pBstrSource) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrSource); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSource(ref char* pBstrSource) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrSourcePtr = &pBstrSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrSourcePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(char** pBstrDescription) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pBstrDescription); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(ref char* pBstrDescription) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDescriptionPtr = &pBstrDescription) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pBstrDescriptionPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHelpFile(char** pBstrHelpFile) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetHelpFile(ref char* pBstrHelpFile) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHelpContext(uint* pdwHelpContext) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pdwHelpContext); + return ret; + } + + /// To be documented. + public readonly int GetHelpContext(ref uint pdwHelpContext) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pdwHelpContextPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetSource(string[] pBstrSourceSa) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrSource = (char**) SilkMarshal.StringArrayToPtr(pBstrSourceSa); + var ret = @this->GetSource(pBstrSource); + SilkMarshal.CopyPtrToStringArray((nint) pBstrSource, pBstrSourceSa); + SilkMarshal.Free((nint) pBstrSource); + return ret; + } + + /// To be documented. + public readonly int GetDescription(string[] pBstrDescriptionSa) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDescription = (char**) SilkMarshal.StringArrayToPtr(pBstrDescriptionSa); + var ret = @this->GetDescription(pBstrDescription); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDescription, pBstrDescriptionSa); + SilkMarshal.Free((nint) pBstrDescription); + return ret; + } + + /// To be documented. + public readonly int GetHelpFile(string[] pBstrHelpFileSa) + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetHelpFile(pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorLog.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorLog.gen.cs new file mode 100644 index 0000000000..ba25def544 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IErrorLog.gen.cs @@ -0,0 +1,205 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("3127ca40-446e-11ce-8135-00aa004bb851")] + [NativeName("Name", "IErrorLog")] + public unsafe partial struct IErrorLog : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3127ca40-446e-11ce-8135-00aa004bb851"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IErrorLog val) + => Unsafe.As(ref val); + + public IErrorLog + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pExcepInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pExcepInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfo); + } + return ret; + } + + /// To be documented. + public readonly int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ExceptionInfo* pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfo); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly int AddError([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref ExceptionInfo pExcepInfo) + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pExcepInfoPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IErrorLog*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IObjectWithSite.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IObjectWithSite.gen.cs new file mode 100644 index 0000000000..9d67de89cb --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IObjectWithSite.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("fc4801a3-2ba9-11cf-a229-00aa003d7352")] + [NativeName("Name", "IObjectWithSite")] + public unsafe partial struct IObjectWithSite : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("fc4801a3-2ba9-11cf-a229-00aa003d7352"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IObjectWithSite val) + => Unsafe.As(ref val); + + public IObjectWithSite + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetSite(Silk.NET.Core.Native.IUnknown* pUnkSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUnkSite); + return ret; + } + + /// To be documented. + public readonly int SetSite(ref Silk.NET.Core.Native.IUnknown pUnkSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSitePtr = &pUnkSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUnkSitePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSite(Guid* riid, void** ppvSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppvSite); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSite(Guid* riid, ref void* ppvSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvSitePtr = &ppvSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppvSitePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSite(ref Guid riid, void** ppvSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppvSite); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSite(ref Guid riid, ref void* ppvSite) + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvSitePtr = &ppvSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppvSitePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int SetSite(ComPtr pUnkSite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetSite((Silk.NET.Core.Native.IUnknown*) pUnkSite.Handle); + } + + /// To be documented. + public readonly int GetSite(out ComPtr ppvSite) where TI0 : unmanaged, IComVtbl + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvSite = default; + return @this->GetSite(SilkMarshal.GuidPtrOf(), (void**) ppvSite.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr GetSite() where TI0 : unmanaged, IComVtbl + { + var @this = (IObjectWithSite*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetSite(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleParentUndoUnit.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleParentUndoUnit.gen.cs new file mode 100644 index 0000000000..0782db33bd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleParentUndoUnit.gen.cs @@ -0,0 +1,391 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("a1faf330-ef97-11ce-9bc9-00aa00608e01")] + [NativeName("Name", "IOleParentUndoUnit")] + public unsafe partial struct IOleParentUndoUnit : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a1faf330-ef97-11ce-9bc9-00aa00608e01"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IOleUndoUnit(IOleParentUndoUnit val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IOleParentUndoUnit val) + => Unsafe.As(ref val); + + public IOleParentUndoUnit + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Do(IOleUndoManager* pUndoManager) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManager); + return ret; + } + + /// To be documented. + public readonly int Do(ref IOleUndoManager pUndoManager) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoManager* pUndoManagerPtr = &pUndoManager) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManagerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(char** pBstr) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(ref char* pBstr) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(Guid* pClsid, int* plID) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plID); + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(Guid* pClsid, ref int plID) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plIDPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(ref Guid pClsid, int* plID) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plID); + } + return ret; + } + + /// To be documented. + public readonly int GetUnitType(ref Guid pClsid, ref int plID) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plIDPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int OnNextAdd() + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Open(IOleParentUndoUnit* pPUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pPUU); + return ret; + } + + /// To be documented. + public readonly int Open(ref IOleParentUndoUnit pPUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pPUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Close(IOleParentUndoUnit* pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pPUU, fCommit); + return ret; + } + + /// To be documented. + public readonly int Close(ref IOleParentUndoUnit pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pPUUPtr, fCommit); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Add(IOleUndoUnit* pUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int Add(ref IOleUndoUnit pUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindUnit(IOleUndoUnit* pUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int FindUnit(ref IOleUndoUnit pUU) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetParentState(uint* pdwState) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pdwState); + return ret; + } + + /// To be documented. + public readonly int GetParentState(ref uint pdwState) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwStatePtr = &pdwState) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pdwStatePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Do(ComPtr pUndoManager) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Do((IOleUndoManager*) pUndoManager.Handle); + } + + /// To be documented. + public readonly int GetDescription(string[] pBstrSa) + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public readonly int Open(ComPtr pPUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Open((IOleParentUndoUnit*) pPUU.Handle); + } + + /// To be documented. + public readonly int Close(ComPtr pPUU, Silk.NET.Core.Bool32 fCommit) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Close((IOleParentUndoUnit*) pPUU.Handle, fCommit); + } + + /// To be documented. + public readonly int Add(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Add((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly int FindUnit(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindUnit((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IOleParentUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoManager.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoManager.gen.cs new file mode 100644 index 0000000000..eb180f4a1f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoManager.gen.cs @@ -0,0 +1,460 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("d001f200-ef97-11ce-9bc9-00aa00608e01")] + [NativeName("Name", "IOleUndoManager")] + public unsafe partial struct IOleUndoManager : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("d001f200-ef97-11ce-9bc9-00aa00608e01"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IOleUndoManager val) + => Unsafe.As(ref val); + + public IOleUndoManager + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Open(IOleParentUndoUnit* pPUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPUU); + return ret; + } + + /// To be documented. + public readonly int Open(ref IOleParentUndoUnit pPUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Close(IOleParentUndoUnit* pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPUU, fCommit); + return ret; + } + + /// To be documented. + public readonly int Close(ref IOleParentUndoUnit pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPUUPtr, fCommit); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Add(IOleUndoUnit* pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int Add(ref IOleUndoUnit pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetOpenParentState(uint* pdwState) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pdwState); + return ret; + } + + /// To be documented. + public readonly int GetOpenParentState(ref uint pdwState) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwStatePtr = &pdwState) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pdwStatePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DiscardFrom(IOleUndoUnit* pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int DiscardFrom(ref IOleUndoUnit pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int UndoTo(IOleUndoUnit* pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int UndoTo(ref IOleUndoUnit pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RedoTo(IOleUndoUnit* pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUU); + return ret; + } + + /// To be documented. + public readonly int RedoTo(ref IOleUndoUnit pUU) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumUndoable(IEnumOleUndoUnits** ppEnum) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumUndoable(ref IEnumOleUndoUnits* ppEnum) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumRedoable(IEnumOleUndoUnits** ppEnum) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppEnum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumRedoable(ref IEnumOleUndoUnits* ppEnum) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLastUndoDescription(char** pBstr) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pBstr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLastUndoDescription(ref char* pBstr) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLastRedoDescription(char** pBstr) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pBstr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLastRedoDescription(ref char* pBstr) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public readonly int Enable(Silk.NET.Core.Bool32 fEnable) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, fEnable); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Open(ComPtr pPUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Open((IOleParentUndoUnit*) pPUU.Handle); + } + + /// To be documented. + public readonly int Close(ComPtr pPUU, Silk.NET.Core.Bool32 fCommit) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Close((IOleParentUndoUnit*) pPUU.Handle, fCommit); + } + + /// To be documented. + public readonly int Add(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Add((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly int DiscardFrom(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->DiscardFrom((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly int UndoTo(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->UndoTo((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly int RedoTo(ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RedoTo((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public readonly int EnumUndoable(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumUndoable((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumRedoable(ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumRedoable((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public readonly int GetLastUndoDescription(string[] pBstrSa) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetLastUndoDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public readonly int GetLastRedoDescription(string[] pBstrSa) + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetLastRedoDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IOleUndoManager*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoUnit.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoUnit.gen.cs new file mode 100644 index 0000000000..588987d0f9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOleUndoUnit.gen.cs @@ -0,0 +1,251 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("894ad3b0-ef97-11ce-9bc9-00aa00608e01")] + [NativeName("Name", "IOleUndoUnit")] + public unsafe partial struct IOleUndoUnit : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("894ad3b0-ef97-11ce-9bc9-00aa00608e01"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IOleUndoUnit val) + => Unsafe.As(ref val); + + public IOleUndoUnit + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Do(IOleUndoManager* pUndoManager) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManager); + return ret; + } + + /// To be documented. + public readonly int Do(ref IOleUndoManager pUndoManager) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IOleUndoManager* pUndoManagerPtr = &pUndoManager) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManagerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(char** pBstr) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDescription(ref char* pBstr) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(Guid* pClsid, int* plID) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plID); + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(Guid* pClsid, ref int plID) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plIDPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetUnitType(ref Guid pClsid, int* plID) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plID); + } + return ret; + } + + /// To be documented. + public readonly int GetUnitType(ref Guid pClsid, ref int plID) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plIDPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int OnNextAdd() + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Do(ComPtr pUndoManager) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Do((IOleUndoManager*) pUndoManager.Handle); + } + + /// To be documented. + public readonly int GetDescription(string[] pBstrSa) + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IOleUndoUnit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPerPropertyBrowsing.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPerPropertyBrowsing.gen.cs new file mode 100644 index 0000000000..98794407a3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPerPropertyBrowsing.gen.cs @@ -0,0 +1,255 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("376bd3aa-3845-101b-84ed-08002b2ec713")] + [NativeName("Name", "IPerPropertyBrowsing")] + public unsafe partial struct IPerPropertyBrowsing : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("376bd3aa-3845-101b-84ed-08002b2ec713"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPerPropertyBrowsing val) + => Unsafe.As(ref val); + + public IPerPropertyBrowsing + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayString(int dispID, char** pBstr) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID, pBstr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayString(int dispID, ref char* pBstr) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID, pBstrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MapPropertyToPage(int dispID, Guid* pClsid) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID, pClsid); + return ret; + } + + /// To be documented. + public readonly int MapPropertyToPage(int dispID, ref Guid pClsid) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID, pClsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPredefinedStrings(int dispID, CALPOLESTR* pCaStringsOut, CADWORD* pCaCookiesOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOut, pCaCookiesOut); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPredefinedStrings(int dispID, CALPOLESTR* pCaStringsOut, ref CADWORD pCaCookiesOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CADWORD* pCaCookiesOutPtr = &pCaCookiesOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOut, pCaCookiesOutPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPredefinedStrings(int dispID, ref CALPOLESTR pCaStringsOut, CADWORD* pCaCookiesOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CALPOLESTR* pCaStringsOutPtr = &pCaStringsOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOutPtr, pCaCookiesOut); + } + return ret; + } + + /// To be documented. + public readonly int GetPredefinedStrings(int dispID, ref CALPOLESTR pCaStringsOut, ref CADWORD pCaCookiesOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CALPOLESTR* pCaStringsOutPtr = &pCaStringsOut) + { + fixed (CADWORD* pCaCookiesOutPtr = &pCaCookiesOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOutPtr, pCaCookiesOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPredefinedValue(int dispID, uint dwCookie, Variant* pVarOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispID, dwCookie, pVarOut); + return ret; + } + + /// To be documented. + public readonly int GetPredefinedValue(int dispID, uint dwCookie, ref Variant pVarOut) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarOutPtr = &pVarOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispID, dwCookie, pVarOutPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetDisplayString(int dispID, string[] pBstrSa) + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDisplayString(dispID, pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPerPropertyBrowsing*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistMemory.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistMemory.gen.cs new file mode 100644 index 0000000000..81660a1ec5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistMemory.gen.cs @@ -0,0 +1,237 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("bd1ae5e0-a6ae-11ce-bd37-504200c10000")] + [NativeName("Name", "IPersistMemory")] + public unsafe partial struct IPersistMemory : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("bd1ae5e0-a6ae-11ce-bd37-504200c10000"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersist(IPersistMemory val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersistMemory val) + => Unsafe.As(ref val); + + public IPersistMemory + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load(void* pMem, uint cbSize) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pMem, cbSize); + return ret; + } + + /// To be documented. + public readonly int Load(ref T0 pMem, uint cbSize) where T0 : unmanaged + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pMemPtr = &pMem) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pMemPtr, cbSize); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pMem, fClearDirty, cbSize); + return ret; + } + + /// To be documented. + public readonly int Save(ref T0 pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pMemPtr = &pMem) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pMemPtr, fClearDirty, cbSize); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeMax(uint* pCbSize) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSize); + return ret; + } + + /// To be documented. + public readonly int GetSizeMax(ref uint pCbSize) + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pCbSizePtr = &pCbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly int InitNew() + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistMemory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStreamInit.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStreamInit.gen.cs new file mode 100644 index 0000000000..5eceba7c5a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStreamInit.gen.cs @@ -0,0 +1,253 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("7fd52380-4e07-101b-ae2d-08002b2ec713")] + [NativeName("Name", "IPersistStreamInit")] + public unsafe partial struct IPersistStreamInit : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("7fd52380-4e07-101b-ae2d-08002b2ec713"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersist(IPersistStreamInit val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersistStreamInit val) + => Unsafe.As(ref val); + + public IPersistStreamInit + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load(Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public readonly int Load(ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public readonly int Save(ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeMax(ulong* pCbSize) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSize); + return ret; + } + + /// To be documented. + public readonly int GetSizeMax(ref ulong pCbSize) + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pCbSizePtr = &pCbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly int InitNew() + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Load(ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public readonly int Save(ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStreamInit*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPrintDocumentPackageStatusEvent.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPrintDocumentPackageStatusEvent.gen.cs index 54931231aa..de01f69b7b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPrintDocumentPackageStatusEvent.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPrintDocumentPackageStatusEvent.gen.cs @@ -18,13 +18,16 @@ namespace Silk.NET.Core.Win32Extras { [Guid("ed90c8ad-5c34-4d05-a1ec-0e8a9b3ad7af")] [NativeName("Name", "IPrintDocumentPackageStatusEvent")] - public unsafe partial struct IPrintDocumentPackageStatusEvent : IComVtbl, IComVtbl + public unsafe partial struct IPrintDocumentPackageStatusEvent : IComVtbl, IComVtbl, IComVtbl { public static readonly Guid Guid = new("ed90c8ad-5c34-4d05-a1ec-0e8a9b3ad7af"); void*** IComVtbl.AsVtblPtr() => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + public static implicit operator IDispatch(IPrintDocumentPackageStatusEvent val) + => Unsafe.As(ref val); + public static implicit operator Silk.NET.Core.Native.IUnknown(IPrintDocumentPackageStatusEvent val) => Unsafe.As(ref val); @@ -132,22 +135,22 @@ public readonly int GetTypeInfoCount(ref uint pctinfo) } /// To be documented. - public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, Silk.NET.Core.Native.IUnknown** ppTInfo) + public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, ITypeInfo** ppTInfo) { var @this = (IPrintDocumentPackageStatusEvent*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); return ret; } /// To be documented. - public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, ref Silk.NET.Core.Native.IUnknown* ppTInfo) + public readonly unsafe int GetTypeInfo(uint iTInfo, uint lcid, ref ITypeInfo* ppTInfo) { var @this = (IPrintDocumentPackageStatusEvent*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppTInfoPtr = &ppTInfo) + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); } return ret; } @@ -789,22 +792,22 @@ public readonly int Invoke(int dispIdMember, ref Guid riid, uint lcid, ushort wF } /// To be documented. - public readonly unsafe int PackageStatusUpdated(MIDLMIDLItfDocumenttarget000000020001* packageStatus) + public readonly unsafe int PackageStatusUpdated(MIDLMIDLItfDocumentTarget000000020001* packageStatus) { var @this = (IPrintDocumentPackageStatusEvent*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatus); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatus); return ret; } /// To be documented. - public readonly int PackageStatusUpdated(ref MIDLMIDLItfDocumenttarget000000020001 packageStatus) + public readonly int PackageStatusUpdated(ref MIDLMIDLItfDocumentTarget000000020001 packageStatus) { var @this = (IPrintDocumentPackageStatusEvent*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (MIDLMIDLItfDocumenttarget000000020001* packageStatusPtr = &packageStatus) + fixed (MIDLMIDLItfDocumentTarget000000020001* packageStatusPtr = &packageStatus) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatusPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatusPtr); } return ret; } @@ -819,11 +822,11 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly int GetTypeInfo(uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int GetTypeInfo(uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IPrintDocumentPackageStatusEvent*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader - return @this->GetTypeInfo(iTInfo, lcid, (Silk.NET.Core.Native.IUnknown**) ppTInfo.GetAddressOf()); + return @this->GetTypeInfo(iTInfo, lcid, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag.gen.cs new file mode 100644 index 0000000000..dda1954537 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag.gen.cs @@ -0,0 +1,417 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("55272a00-42cb-11ce-8135-00aa004bb851")] + [NativeName("Name", "IPropertyBag")] + public unsafe partial struct IPropertyBag : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("55272a00-42cb-11ce-8135-00aa004bb851"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPropertyBag val) + => Unsafe.As(ref val); + + public IPropertyBag + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVar, pErrorLog); + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVar, pErrorLogPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVarPtr, pErrorLog); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVarPtr, pErrorLogPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLog); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLogPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLog); + } + } + return ret; + } + + /// To be documented. + public readonly int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLogPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLog); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLogPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLog); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLogPtr); + } + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropName, pVar); + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropName, pVarPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVar); + } + return ret; + } + + /// To be documented. + public readonly int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVarPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVar); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly int Write([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar) + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVarPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly int Read([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly unsafe int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly int Read([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyBag*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag2.gen.cs new file mode 100644 index 0000000000..bc7a734091 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyBag2.gen.cs @@ -0,0 +1,789 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("22f55882-280b-11d0-a8a9-00a0c90c2004")] + [NativeName("Name", "IPropertyBag2")] + public unsafe partial struct IPropertyBag2 : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("22f55882-280b-11d0-a8a9-00a0c90c2004"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPropertyBag2 val) + => Unsafe.As(ref val); + + public IPropertyBag2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValue, phrError); + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValue, phrErrorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValuePtr, phrError); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValuePtr, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValue, phrError); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValue, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValuePtr, phrError); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValuePtr, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, Variant* pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValue, phrError); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValue, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValuePtr, phrError); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValuePtr, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValue, phrError); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValue, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValuePtr, phrError); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Read(uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValuePtr, phrErrorPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write(uint cProperties, PropBag2* pPropBag, Variant* pvarValue) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBag, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int Write(uint cProperties, PropBag2* pPropBag, ref Variant pvarValue) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBag, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write(uint cProperties, ref PropBag2 pPropBag, Variant* pvarValue) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBagPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly int Write(uint cProperties, ref PropBag2 pPropBag, ref Variant pvarValue) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBagPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CountProperties(uint* pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcProperties); + return ret; + } + + /// To be documented. + public readonly int CountProperties(ref uint pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcPropertiesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPropertyInfo(uint iProperty, uint cProperties, PropBag2* pPropBag, uint* pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBag, pcProperties); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPropertyInfo(uint iProperty, uint cProperties, PropBag2* pPropBag, ref uint pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBag, pcPropertiesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPropertyInfo(uint iProperty, uint cProperties, ref PropBag2 pPropBag, uint* pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBagPtr, pcProperties); + } + return ret; + } + + /// To be documented. + public readonly int GetPropertyInfo(uint iProperty, uint cProperties, ref PropBag2 pPropBag, ref uint pcProperties) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBagPtr, pcPropertiesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObject, pErrLog); + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObject, pErrLogPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObjectPtr, pErrLog); + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLog); + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLogPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLog); + } + } + return ret; + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLog); + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLogPtr); + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLog); + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, Variant* pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, Variant* pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, ref phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, ref Variant pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, ref Variant pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, ref phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, Variant* pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, Variant* pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, ref phrError); + } + + /// To be documented. + public readonly unsafe int Read(uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, ref Variant pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, phrError); + } + + /// To be documented. + public readonly int Read(uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, ref Variant pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, ref phrError); + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public readonly unsafe int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public readonly int LoadObject([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyBag2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyNotifySink.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyNotifySink.gen.cs new file mode 100644 index 0000000000..9a683a71a4 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyNotifySink.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("9bfbbc02-eff1-101a-84ed-00aa00341d07")] + [NativeName("Name", "IPropertyNotifySink")] + public unsafe partial struct IPropertyNotifySink : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("9bfbbc02-eff1-101a-84ed-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPropertyNotifySink val) + => Unsafe.As(ref val); + + public IPropertyNotifySink + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int OnChanged(int dispID) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID); + return ret; + } + + /// To be documented. + public readonly int OnRequestEdit(int dispID) + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyNotifySink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertySetStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertySetStorage.gen.cs new file mode 100644 index 0000000000..930526d89d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertySetStorage.gen.cs @@ -0,0 +1,386 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000013a-0000-0000-c000-000000000046")] + [NativeName("Name", "IPropertySetStorage")] + public unsafe partial struct IPropertySetStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000013a-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPropertySetStorage val) + => Unsafe.As(ref val); + + public IPropertySetStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsid, grfFlags, grfMode, ppprstg); + return ret; + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsid, grfFlags, grfMode, ppprstgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsidPtr, grfFlags, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsidPtr, grfFlags, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsid, grfFlags, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsid, grfFlags, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsidPtr, grfFlags, grfMode, ppprstg); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (Guid* pclsidPtr = &pclsid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsidPtr, grfFlags, grfMode, ppprstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Open(Guid* rfmtid, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtid, grfMode, ppprstg); + return ret; + } + + /// To be documented. + public readonly unsafe int Open(Guid* rfmtid, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtid, grfMode, ppprstgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Open(ref Guid rfmtid, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtidPtr, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Open(ref Guid rfmtid, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtidPtr, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Delete(Guid* rfmtid) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rfmtid); + return ret; + } + + /// To be documented. + public readonly int Delete(ref Guid rfmtid) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rfmtidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(IEnumSTATPROPSETSTG** ppenum) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(ref IEnumSTATPROPSETSTG* ppenum) + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATPROPSETSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Create(rfmtid, pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Create(Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Create(rfmtid, in pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Create(ref rfmtid, pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly int Create(ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Create(ref rfmtid, in pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Open(Guid* rfmtid, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Open(rfmtid, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly int Open(ref Guid rfmtid, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Open(ref rfmtid, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public readonly int Enum(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Enum((IEnumSTATPROPSETSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertySetStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyStorage.gen.cs new file mode 100644 index 0000000000..16a985208e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPropertyStorage.gen.cs @@ -0,0 +1,611 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000138-0000-0000-c000-000000000046")] + [NativeName("Name", "IPropertyStorage")] + public unsafe partial struct IPropertyStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000138-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPropertyStorage val) + => Unsafe.As(ref val); + + public IPropertyStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int ReadMultiple(uint cpspec, PropSpec* rgpspec, PropVariant* rgpropvar) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspec, rgpropvar); + return ret; + } + + /// To be documented. + public readonly unsafe int ReadMultiple(uint cpspec, PropSpec* rgpspec, ref PropVariant rgpropvar) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspec, rgpropvarPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ReadMultiple(uint cpspec, ref PropSpec rgpspec, PropVariant* rgpropvar) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspecPtr, rgpropvar); + } + return ret; + } + + /// To be documented. + public readonly int ReadMultiple(uint cpspec, ref PropSpec rgpspec, ref PropVariant rgpropvar) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspecPtr, rgpropvarPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteMultiple(uint cpspec, PropSpec* rgpspec, PropVariant* rgpropvar, uint propidNameFirst) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspec, rgpropvar, propidNameFirst); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteMultiple(uint cpspec, PropSpec* rgpspec, ref PropVariant rgpropvar, uint propidNameFirst) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspec, rgpropvarPtr, propidNameFirst); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteMultiple(uint cpspec, ref PropSpec rgpspec, PropVariant* rgpropvar, uint propidNameFirst) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspecPtr, rgpropvar, propidNameFirst); + } + return ret; + } + + /// To be documented. + public readonly int WriteMultiple(uint cpspec, ref PropSpec rgpspec, ref PropVariant rgpropvar, uint propidNameFirst) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspecPtr, rgpropvarPtr, propidNameFirst); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DeleteMultiple(uint cpspec, PropSpec* rgpspec) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, cpspec, rgpspec); + return ret; + } + + /// To be documented. + public readonly int DeleteMultiple(uint cpspec, ref PropSpec rgpspec) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, cpspec, rgpspecPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ReadPropertyNames(uint cpropid, uint* rgpropid, char** rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropid, rglpwstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int ReadPropertyNames(uint cpropid, uint* rgpropid, ref char* rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropid, rglpwstrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ReadPropertyNames(uint cpropid, ref uint rgpropid, char** rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropidPtr, rglpwstrName); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ReadPropertyNames(uint cpropid, ref uint rgpropid, ref char* rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropidPtr, rglpwstrNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WritePropertyNames(uint cpropid, uint* rgpropid, char** rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropid, rglpwstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int WritePropertyNames(uint cpropid, uint* rgpropid, ref char* rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropid, rglpwstrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WritePropertyNames(uint cpropid, ref uint rgpropid, char** rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropidPtr, rglpwstrName); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WritePropertyNames(uint cpropid, ref uint rgpropid, ref char* rglpwstrName) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropidPtr, rglpwstrNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DeletePropertyNames(uint cpropid, uint* rgpropid) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, cpropid, rgpropid); + return ret; + } + + /// To be documented. + public readonly int DeletePropertyNames(uint cpropid, ref uint rgpropid) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, cpropid, rgpropidPtr); + } + return ret; + } + + /// To be documented. + public readonly int Commit(uint grfCommitFlags) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public readonly int Revert() + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(IEnumSTATPROPSTG** ppenum) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(ref IEnumSTATPROPSTG* ppenum) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATPROPSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patime, pmtime); + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patime, pmtimePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patimePtr, pmtime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patimePtr, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patime, pmtime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public readonly int SetTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetClass(Guid* clsid) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, clsid); + return ret; + } + + /// To be documented. + public readonly int SetClass(ref Guid clsid) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidPtr = &clsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, clsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Stat(STATPROPSETSTG* pstatpsstg) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pstatpsstg); + return ret; + } + + /// To be documented. + public readonly int Stat(ref STATPROPSETSTG pstatpsstg) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATPROPSETSTG* pstatpsstgPtr = &pstatpsstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pstatpsstgPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ReadPropertyNames(uint cpropid, uint* rgpropid, string[] rglpwstrNameSa) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->ReadPropertyNames(cpropid, rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public readonly int ReadPropertyNames(uint cpropid, ref uint rgpropid, string[] rglpwstrNameSa) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->ReadPropertyNames(cpropid, ref rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int WritePropertyNames(uint cpropid, uint* rgpropid, string[] rglpwstrNameSa) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->WritePropertyNames(cpropid, rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public readonly int WritePropertyNames(uint cpropid, ref uint rgpropid, string[] rglpwstrNameSa) + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->WritePropertyNames(cpropid, ref rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public readonly int Enum(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Enum((IEnumSTATPROPSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPropertyStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo.gen.cs new file mode 100644 index 0000000000..4bcc597fed --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo.gen.cs @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b283-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "IProvideClassInfo")] + public unsafe partial struct IProvideClassInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b283-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IProvideClassInfo val) + => Unsafe.As(ref val); + + public IProvideClassInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ITypeInfo** ppTI) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ref ITypeInfo* ppTI) + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetClassInfoA(ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo2.gen.cs new file mode 100644 index 0000000000..a596ef771b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideClassInfo2.gen.cs @@ -0,0 +1,185 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("a6bc3ac0-dbaa-11ce-9de3-00aa004bb851")] + [NativeName("Name", "IProvideClassInfo2")] + public unsafe partial struct IProvideClassInfo2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a6bc3ac0-dbaa-11ce-9de3-00aa004bb851"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IProvideClassInfo(IProvideClassInfo2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IProvideClassInfo2 val) + => Unsafe.As(ref val); + + public IProvideClassInfo2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ITypeInfo** ppTI) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ref ITypeInfo* ppTI) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetGUID(uint dwGuidKind, Guid* pGUID) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUID); + return ret; + } + + /// To be documented. + public readonly int GetGUID(uint dwGuidKind, ref Guid pGUID) + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetClassInfoA(ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideClassInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideMultipleClassInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideMultipleClassInfo.gen.cs new file mode 100644 index 0000000000..3ab86b6ead --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProvideMultipleClassInfo.gen.cs @@ -0,0 +1,865 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("a7aba9c1-8983-11cf-8f20-00805f2cd064")] + [NativeName("Name", "IProvideMultipleClassInfo")] + public unsafe partial struct IProvideMultipleClassInfo : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a7aba9c1-8983-11cf-8f20-00805f2cd064"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IProvideClassInfo2(IProvideMultipleClassInfo val) + => Unsafe.As(ref val); + + public static implicit operator IProvideClassInfo(IProvideMultipleClassInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IProvideMultipleClassInfo val) + => Unsafe.As(ref val); + + public IProvideMultipleClassInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ITypeInfo** ppTI) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassInfoA(ref ITypeInfo* ppTI) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetGUID(uint dwGuidKind, Guid* pGUID) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUID); + return ret; + } + + /// To be documented. + public readonly int GetGUID(uint dwGuidKind, ref Guid pGUID) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMultiTypeInfoCount(uint* pcti) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcti); + return ret; + } + + /// To be documented. + public readonly int GetMultiTypeInfoCount(ref uint pcti) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pctiPtr = &pcti) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pctiPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSourcePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSource); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetClassInfoA(ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly unsafe int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public readonly int GetInfoOfIndex(uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IProvideMultipleClassInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRecordInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRecordInfo.gen.cs new file mode 100644 index 0000000000..c86ba64518 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRecordInfo.gen.cs @@ -0,0 +1,1361 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000002f-0000-0000-c000-000000000046")] + [NativeName("Name", "IRecordInfo")] + public unsafe partial struct IRecordInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000002f-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IRecordInfo val) + => Unsafe.As(ref val); + + public IRecordInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int RecordInit(void* pvNew) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvNew); + return ret; + } + + /// To be documented. + public readonly int RecordInit(ref T0 pvNew) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvNewPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordClear(void* pvExisting) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvExisting); + return ret; + } + + /// To be documented. + public readonly int RecordClear(ref T0 pvExisting) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvExistingPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCopy(void* pvExisting, void* pvNew) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExisting, pvNew); + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCopy(void* pvExisting, ref T0 pvNew) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExisting, pvNewPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCopy(ref T0 pvExisting, void* pvNew) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExistingPtr, pvNew); + } + return ret; + } + + /// To be documented. + public readonly int RecordCopy(ref T0 pvExisting, ref T1 pvNew) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExistingPtr, pvNewPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetGuid(Guid* pguid) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pguid); + return ret; + } + + /// To be documented. + public readonly int GetGuid(ref Guid pguid) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPtr = &pguid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pguidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetName(char** pbstrName) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetName(ref char* pbstrName) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrNamePtr = &pbstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbstrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* pcbSize) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pcbSize); + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint pcbSize) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(ITypeInfo** ppTypeInfo) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppTypeInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(ref ITypeInfo* ppTypeInfo) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTypeInfoPtr = &ppTypeInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppTypeInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public readonly int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int GetField(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarField, ppvDataCArray); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarField, ppvDataCArrayPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarFieldPtr, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarFieldPtr, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArray); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarField, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarField, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarFieldPtr, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArray); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNoCopy(ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public readonly int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int PutField(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public readonly int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int PutFieldNoCopy(uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNames(uint* pcNames, char** rgBstrNames) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNames, rgBstrNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNames(uint* pcNames, ref char* rgBstrNames) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNames, rgBstrNamesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNames(ref uint pcNames, char** rgBstrNames) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNamesPtr, rgBstrNames); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFieldNames(ref uint pcNames, ref char* rgBstrNames) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNamesPtr, rgBstrNamesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe Silk.NET.Core.Bool32 IsMatchingType(IRecordInfo* pRecordInfo) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + Silk.NET.Core.Bool32 ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pRecordInfo); + return ret; + } + + /// To be documented. + public readonly Silk.NET.Core.Bool32 IsMatchingType(ref IRecordInfo pRecordInfo) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + Silk.NET.Core.Bool32 ret = default; + fixed (IRecordInfo* pRecordInfoPtr = &pRecordInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pRecordInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe void* RecordCreate() + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCreateCopy(void* pvSource, void** ppvDest) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSource, ppvDest); + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCreateCopy(void* pvSource, ref void* ppvDest) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvDestPtr = &ppvDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSource, ppvDestPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCreateCopy(ref T0 pvSource, void** ppvDest) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvSourcePtr = &pvSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSourcePtr, ppvDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordCreateCopy(ref T0 pvSource, ref void* ppvDest) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvSourcePtr = &pvSource) + { + fixed (void** ppvDestPtr = &ppvDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSourcePtr, ppvDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RecordDestroy(void* pvRecord) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pvRecord); + return ret; + } + + /// To be documented. + public readonly int RecordDestroy(ref T0 pvRecord) where T0 : unmanaged + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvRecordPtr = &pvRecord) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pvRecordPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetName(string[] pbstrNameSa) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrName = (char**) SilkMarshal.StringArrayToPtr(pbstrNameSa); + var ret = @this->GetName(pbstrName); + SilkMarshal.CopyPtrToStringArray((nint) pbstrName, pbstrNameSa); + SilkMarshal.Free((nint) pbstrName); + return ret; + } + + /// To be documented. + public readonly int GetTypeInfo(ref ComPtr ppTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfo((ITypeInfo**) ppTypeInfo.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetFieldNames(uint* pcNames, string[] rgBstrNamesSa) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetFieldNames(pcNames, rgBstrNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly int GetFieldNames(ref uint pcNames, string[] rgBstrNamesSa) + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetFieldNames(ref pcNames, rgBstrNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly Silk.NET.Core.Bool32 IsMatchingType(ComPtr pRecordInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsMatchingType((IRecordInfo*) pRecordInfo.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IRecordInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ISpecifyPropertyPages.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISpecifyPropertyPages.gen.cs new file mode 100644 index 0000000000..229365bb3d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISpecifyPropertyPages.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("b196b28b-bab4-101a-b69c-00aa00341d07")] + [NativeName("Name", "ISpecifyPropertyPages")] + public unsafe partial struct ISpecifyPropertyPages : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b196b28b-bab4-101a-b69c-00aa00341d07"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ISpecifyPropertyPages val) + => Unsafe.As(ref val); + + public ISpecifyPropertyPages + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPages(CAUUID* pPages) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPages); + return ret; + } + + /// To be documented. + public readonly int GetPages(ref CAUUID pPages) + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CAUUID* pPagesPtr = &pPages) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPagesPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ISpecifyPropertyPages*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ISupportErrorInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISupportErrorInfo.gen.cs new file mode 100644 index 0000000000..7c0f8c6541 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISupportErrorInfo.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("df0b3d60-548f-101b-8e65-08002b2bd119")] + [NativeName("Name", "ISupportErrorInfo")] + public unsafe partial struct ISupportErrorInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("df0b3d60-548f-101b-8e65-08002b2bd119"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ISupportErrorInfo val) + => Unsafe.As(ref val); + + public ISupportErrorInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int InterfaceSupportsErrorInfo(Guid* riid) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, riid); + return ret; + } + + /// To be documented. + public readonly int InterfaceSupportsErrorInfo(ref Guid riid) + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, riidPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ISupportErrorInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeChangeEvents.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeChangeEvents.gen.cs new file mode 100644 index 0000000000..cbc793dea3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeChangeEvents.gen.cs @@ -0,0 +1,441 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020410-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeChangeEvents")] + public unsafe partial struct ITypeChangeEvents : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020410-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeChangeEvents val) + => Unsafe.As(ref val); + + public ITypeChangeEvents + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, char* pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrName, pfCancel); + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, char* pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrName, pfCancelPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, ref char pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancel); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, ref char pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancelPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancel); + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancelPtr); + } + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, char* pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrName, pfCancel); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, char* pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrName, pfCancelPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, ref char pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancel); + } + } + return ret; + } + + /// To be documented. + public readonly int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, ref char pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (char* pStrNamePtr = &pStrName) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancelPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancel); + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int RequestTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancelPtr); + } + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AfterTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoAfter, char* pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrName); + return ret; + } + + /// To be documented. + public readonly unsafe int AfterTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoAfter, ref char pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AfterTypeChange(ChangeKind changeKind, ITypeInfo* pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrNamePtr); + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AfterTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoAfter, char* pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrName); + } + return ret; + } + + /// To be documented. + public readonly int AfterTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoAfter, ref char pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int AfterTypeChange(ChangeKind changeKind, ref ITypeInfo pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrNamePtr); + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, char* pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, pfCancel); + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, char* pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, ref pfCancel); + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, ref char pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, ref pStrName, pfCancel); + } + + /// To be documented. + public readonly int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, ref char pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, ref pStrName, ref pfCancel); + } + + /// To be documented. + public readonly unsafe int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, pfCancel); + } + + /// To be documented. + public readonly int RequestTypeChange(ChangeKind changeKind, ComPtr pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, ref pfCancel); + } + + /// To be documented. + public readonly unsafe int AfterTypeChange(ChangeKind changeKind, ComPtr pTInfoAfter, char* pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, pStrName); + } + + /// To be documented. + public readonly int AfterTypeChange(ChangeKind changeKind, ComPtr pTInfoAfter, ref char pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, ref pStrName); + } + + /// To be documented. + public readonly int AfterTypeChange(ChangeKind changeKind, ComPtr pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, pStrName); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeChangeEvents*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeComp.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeComp.gen.cs new file mode 100644 index 0000000000..9cdbb40a72 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeComp.gen.cs @@ -0,0 +1,828 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020403-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeComp")] + public unsafe partial struct ITypeComp : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020403-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeComp val) + => Unsafe.As(ref val); + + public ITypeComp + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfo, ppTComp); + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfo, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfoPtr, ppTComp); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTComp); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTCompPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTComp); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTComp); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTCompPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTComp); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public readonly int Bind(ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public readonly int Bind([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public readonly unsafe int BindType(char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly int BindType(ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public readonly unsafe int BindType(ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public readonly unsafe int BindType([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindType(szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeComp*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeFactory.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeFactory.gen.cs new file mode 100644 index 0000000000..6f17ba1a69 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeFactory.gen.cs @@ -0,0 +1,308 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000002e-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeFactory")] + public unsafe partial struct ITypeFactory : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000002e-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeFactory val) + => Unsafe.As(ref val); + + public ITypeFactory + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ITypeInfo* pTypeInfo, Guid* riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riid, ppv); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ITypeInfo* pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riid, ppvPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ITypeInfo* pTypeInfo, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riidPtr, ppv); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ITypeInfo* pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riidPtr, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, Guid* riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riid, ppv); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riid, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riidPtr, ppv); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Guid* riidPtr = &riid) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riidPtr, ppvPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFromTypeInfo(ComPtr pTypeInfo, out ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppv = default; + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ComPtr pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, riid, ref ppv); + } + + /// To be documented. + public readonly int CreateFromTypeInfo(ComPtr pTypeInfo, ref Guid riid, ref ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFromTypeInfo(ComPtr pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, ref riid, ref ppv); + } + + /// To be documented. + public readonly int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, out ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppv = default; + return @this->CreateFromTypeInfo(ref pTypeInfo, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFromTypeInfo(ref ITypeInfo pTypeInfo, ref Guid riid, ref ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo, ref riid, (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateFromTypeInfo(ComPtr pTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateFromTypeInfo(pTypeInfo, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateFromTypeInfo(ref ITypeInfo pTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateFromTypeInfo(ref pTypeInfo, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo.gen.cs new file mode 100644 index 0000000000..89e610bb88 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo.gen.cs @@ -0,0 +1,1928 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020401-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeInfo")] + public unsafe partial struct ITypeInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020401-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeInfo val) + => Unsafe.As(ref val); + + public ITypeInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeAttr(TypeAttr** ppTypeAttr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeAttr(ref TypeAttr* ppTypeAttr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeAttr** ppTypeAttrPtr = &ppTypeAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ITypeComp** ppTComp) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTComp); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ref ITypeComp* ppTComp) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncDesc(uint index, FuncDesc** ppFuncDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDesc); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncDesc(uint index, ref FuncDesc* ppFuncDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (FuncDesc** ppFuncDescPtr = &ppFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarDesc(uint index, VarDesc** ppVarDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDesc); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarDesc(uint index, ref VarDesc* ppVarDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (VarDesc** ppVarDescPtr = &ppVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNamesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNames); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNamesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeOfImplType(uint index, uint* pRefType) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefType); + return ret; + } + + /// To be documented. + public readonly int GetRefTypeOfImplType(uint index, ref uint pRefType) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRefTypePtr = &pRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetImplTypeFlags(uint index, int* pImplTypeFlags) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlags); + return ret; + } + + /// To be documented. + public readonly int GetImplTypeFlags(uint index, ref int pImplTypeFlags) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pImplTypeFlagsPtr = &pImplTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(char** rgszNames, uint cNames, int* pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemId); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(char** rgszNames, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemIdPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref char* rgszNames, uint cNames, int* pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemId); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref char* rgszNames, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemIdPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinalPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinal); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinal); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinal); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinalPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeInfo(uint hRefType, ITypeInfo** ppTInfo) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeInfo(uint hRefType, ref ITypeInfo* ppTInfo) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddressOfMember(int memid, InvokeKind invKind, void** ppv) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppv); + return ret; + } + + /// To be documented. + public readonly unsafe int AddressOfMember(int memid, InvokeKind invKind, ref void* ppv) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppvPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObj); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMops(int memid, char** pBstrMops) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMops); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMops(int memid, ref char* pBstrMops) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrMopsPtr = &pBstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMopsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ITypeLib** ppTLib, uint* pIndex) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndex); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ITypeLib** ppTLib, ref uint pIndex) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndexPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ITypeLib* ppTLib, uint* pIndex) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndex); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ITypeLib* ppTLib, ref uint pIndex) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndexPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe void ReleaseTypeAttr(TypeAttr* pTypeAttr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttr); + } + + /// To be documented. + public readonly void ReleaseTypeAttr(ref TypeAttr pTypeAttr) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TypeAttr* pTypeAttrPtr = &pTypeAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttrPtr); + } + } + + /// To be documented. + public readonly unsafe void ReleaseFuncDesc(FuncDesc* pFuncDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDesc); + } + + /// To be documented. + public readonly void ReleaseFuncDesc(ref FuncDesc pFuncDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDescPtr); + } + } + + /// To be documented. + public readonly unsafe void ReleaseVarDesc(VarDesc* pVarDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDesc); + } + + /// To be documented. + public readonly void ReleaseVarDesc(ref VarDesc pVarDesc) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDescPtr); + } + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeComp(ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly int GetNames(int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(string[] rgszNamesSa, uint cNames, int* pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly int GetIDsOfNames(string[] rgszNamesSa, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly int GetRefTypeInfo(uint hRefType, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetRefTypeInfo(hRefType, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateInstance(ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public readonly int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance(ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMops(int memid, string[] pBstrMopsSa) + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrMops = (char**) SilkMarshal.StringArrayToPtr(pBstrMopsSa); + var ret = @this->GetMops(memid, pBstrMops); + SilkMarshal.CopyPtrToStringArray((nint) pBstrMops, pBstrMopsSa); + SilkMarshal.Free((nint) pBstrMops); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + public readonly int GetContainingTypeLib(ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateInstance(ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo2.gen.cs new file mode 100644 index 0000000000..2e96eb7e66 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeInfo2.gen.cs @@ -0,0 +1,2546 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020412-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeInfo2")] + public unsafe partial struct ITypeInfo2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020412-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator ITypeInfo(ITypeInfo2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeInfo2 val) + => Unsafe.As(ref val); + + public ITypeInfo2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeAttr(TypeAttr** ppTypeAttr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeAttr(ref TypeAttr* ppTypeAttr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeAttr** ppTypeAttrPtr = &ppTypeAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ITypeComp** ppTComp) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTComp); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ref ITypeComp* ppTComp) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncDesc(uint index, FuncDesc** ppFuncDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDesc); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncDesc(uint index, ref FuncDesc* ppFuncDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (FuncDesc** ppFuncDescPtr = &ppFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarDesc(uint index, VarDesc** ppVarDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDesc); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarDesc(uint index, ref VarDesc* ppVarDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (VarDesc** ppVarDescPtr = &ppVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDescPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNamesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNames); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNamesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeOfImplType(uint index, uint* pRefType) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefType); + return ret; + } + + /// To be documented. + public readonly int GetRefTypeOfImplType(uint index, ref uint pRefType) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRefTypePtr = &pRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetImplTypeFlags(uint index, int* pImplTypeFlags) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlags); + return ret; + } + + /// To be documented. + public readonly int GetImplTypeFlags(uint index, ref int pImplTypeFlags) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pImplTypeFlagsPtr = &pImplTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(char** rgszNames, uint cNames, int* pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemId); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(char** rgszNames, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemIdPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref char* rgszNames, uint cNames, int* pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemId); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(ref char* rgszNames, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemIdPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int Invoke(ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinalPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinal); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinal); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinal); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinalPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeInfo(uint hRefType, ITypeInfo** ppTInfo) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRefTypeInfo(uint hRefType, ref ITypeInfo* ppTInfo) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddressOfMember(int memid, InvokeKind invKind, void** ppv) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppv); + return ret; + } + + /// To be documented. + public readonly unsafe int AddressOfMember(int memid, InvokeKind invKind, ref void* ppv) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppvPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObj); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMops(int memid, char** pBstrMops) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMops); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMops(int memid, ref char* pBstrMops) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrMopsPtr = &pBstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMopsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ITypeLib** ppTLib, uint* pIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndex); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ITypeLib** ppTLib, ref uint pIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndexPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ITypeLib* ppTLib, uint* pIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndex); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ITypeLib* ppTLib, ref uint pIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndexPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe void ReleaseTypeAttr(TypeAttr* pTypeAttr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttr); + } + + /// To be documented. + public readonly void ReleaseTypeAttr(ref TypeAttr pTypeAttr) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TypeAttr* pTypeAttrPtr = &pTypeAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttrPtr); + } + } + + /// To be documented. + public readonly unsafe void ReleaseFuncDesc(FuncDesc* pFuncDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDesc); + } + + /// To be documented. + public readonly void ReleaseFuncDesc(ref FuncDesc pFuncDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDescPtr); + } + } + + /// To be documented. + public readonly unsafe void ReleaseVarDesc(VarDesc* pVarDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDesc); + } + + /// To be documented. + public readonly void ReleaseVarDesc(ref VarDesc pVarDesc) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDescPtr); + } + } + + /// To be documented. + public readonly unsafe int GetTypeKind(TypeKind* pTypeKind) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pTypeKind); + return ret; + } + + /// To be documented. + public readonly int GetTypeKind(ref TypeKind pTypeKind) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeKind* pTypeKindPtr = &pTypeKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pTypeKindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeFlags(uint* pTypeFlags) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, pTypeFlags); + return ret; + } + + /// To be documented. + public readonly int GetTypeFlags(ref uint pTypeFlags) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pTypeFlagsPtr = &pTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, pTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncIndexOfMemId(int memid, InvokeKind invKind, uint* pFuncIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, memid, invKind, pFuncIndex); + return ret; + } + + /// To be documented. + public readonly int GetFuncIndexOfMemId(int memid, InvokeKind invKind, ref uint pFuncIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pFuncIndexPtr = &pFuncIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, memid, invKind, pFuncIndexPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarIndexOfMemId(int memid, uint* pVarIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this, memid, pVarIndex); + return ret; + } + + /// To be documented. + public readonly int GetVarIndexOfMemId(int memid, ref uint pVarIndex) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pVarIndexPtr = &pVarIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this, memid, pVarIndexPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCustData(Guid* guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCustData(Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCustData(ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetCustData(ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFuncCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetFuncCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetParamCustData(uint indexFunc, uint indexParam, Guid* guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetParamCustData(uint indexFunc, uint indexParam, Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetParamCustData(uint indexFunc, uint indexParam, ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetParamCustData(uint indexFunc, uint indexParam, ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVarCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetVarCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetImplTypeCustData(uint index, Guid* guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetImplTypeCustData(uint index, Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetImplTypeCustData(uint index, ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetImplTypeCustData(uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllCustData(CustomData* pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllCustData(ref CustomData pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllFuncCustData(uint index, CustomData* pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllFuncCustData(uint index, ref CustomData pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllParamCustData(uint indexFunc, uint indexParam, CustomData* pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, indexFunc, indexParam, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllParamCustData(uint indexFunc, uint indexParam, ref CustomData pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, indexFunc, indexParam, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllVarCustData(uint index, CustomData* pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllVarCustData(uint index, ref CustomData pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllImplTypeCustData(uint index, CustomData* pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllImplTypeCustData(uint index, ref CustomData pCustData) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeComp(ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetNames(int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly int GetNames(int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetIDsOfNames(string[] rgszNamesSa, uint cNames, int* pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly int GetIDsOfNames(string[] rgszNamesSa, uint cNames, ref int pMemId) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDllEntry(int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly int GetRefTypeInfo(uint hRefType, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetRefTypeInfo(hRefType, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateInstance(ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); + } + + /// To be documented. + public readonly unsafe int CreateInstance(ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public readonly int CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance(ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMops(int memid, string[] pBstrMopsSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrMops = (char**) SilkMarshal.StringArrayToPtr(pBstrMopsSa); + var ret = @this->GetMops(memid, pBstrMops); + SilkMarshal.CopyPtrToStringArray((nint) pBstrMops, pBstrMopsSa); + SilkMarshal.Free((nint) pBstrMops); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainingTypeLib(ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + public readonly int GetContainingTypeLib(ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation2(int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateInstance(ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateInstance(ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib.gen.cs new file mode 100644 index 0000000000..7949d1d01d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib.gen.cs @@ -0,0 +1,1303 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020402-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeLib")] + public unsafe partial struct ITypeLib : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020402-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeLib val) + => Unsafe.As(ref val); + + public ITypeLib + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly uint GetTypeInfoCount() + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint index, ITypeInfo** ppTInfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint index, ref ITypeInfo* ppTInfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoType(uint index, TypeKind* pTKind) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKind); + return ret; + } + + /// To be documented. + public readonly int GetTypeInfoType(uint index, ref TypeKind pTKind) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeKind* pTKindPtr = &pTKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(Guid* guid, ITypeInfo** ppTinfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(Guid* guid, ref ITypeInfo* ppTinfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(ref Guid guid, ITypeInfo** ppTinfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(ref Guid guid, ref ITypeInfo* ppTinfo) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibAttr(TLibAttr** ppTLibAttr) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibAttr(ref TLibAttr* ppTLibAttr) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TLibAttr** ppTLibAttrPtr = &ppTLibAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ITypeComp** ppTComp) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTComp); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ref ITypeComp* ppTComp) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(char* szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfName); + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(char* szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(ref char szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + } + return ret; + } + + /// To be documented. + public readonly int IsName(ref char szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly int IsName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe void ReleaseTLibAttr(TLibAttr* pTLibAttr) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttr); + } + + /// To be documented. + public readonly void ReleaseTLibAttr(ref TLibAttr pTLibAttr) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TLibAttr* pTLibAttrPtr = &pTLibAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttrPtr); + } + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfo(uint index, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfo(index, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfoOfGuid(out ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppTinfo = default; + return @this->GetTypeInfoOfGuid(SilkMarshal.GuidPtrOf(), (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfoOfGuid(ref Guid guid, ref ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfoOfGuid(ref guid, (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeComp(ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr GetTypeInfoOfGuid() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetTypeInfoOfGuid(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib2.gen.cs new file mode 100644 index 0000000000..27775a9e3a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLib2.gen.cs @@ -0,0 +1,1609 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00020411-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeLib2")] + public unsafe partial struct ITypeLib2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00020411-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator ITypeLib(ITypeLib2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeLib2 val) + => Unsafe.As(ref val); + + public ITypeLib2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly uint GetTypeInfoCount() + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint index, ITypeInfo** ppTInfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfo(uint index, ref ITypeInfo* ppTInfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoType(uint index, TypeKind* pTKind) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKind); + return ret; + } + + /// To be documented. + public readonly int GetTypeInfoType(uint index, ref TypeKind pTKind) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TypeKind* pTKindPtr = &pTKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKindPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(Guid* guid, ITypeInfo** ppTinfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(Guid* guid, ref ITypeInfo* ppTinfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(ref Guid guid, ITypeInfo** ppTinfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeInfoOfGuid(ref Guid guid, ref ITypeInfo* ppTinfo) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibAttr(TLibAttr** ppTLibAttr) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibAttr(ref TLibAttr* ppTLibAttr) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TLibAttr** ppTLibAttrPtr = &ppTLibAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttrPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ITypeComp** ppTComp) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTComp); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTypeComp(ref ITypeComp* ppTComp) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(char* szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfName); + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(char* szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName(ref char szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + } + return ret; + } + + /// To be documented. + public readonly int IsName(ref char szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly int IsName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public readonly unsafe void ReleaseTLibAttr(TLibAttr* pTLibAttr) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttr); + } + + /// To be documented. + public readonly void ReleaseTLibAttr(ref TLibAttr pTLibAttr) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TLibAttr* pTLibAttrPtr = &pTLibAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttrPtr); + } + } + + /// To be documented. + public readonly unsafe int GetCustData(Guid* guid, Variant* pVarVal) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCustData(Guid* guid, ref Variant pVarVal) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCustData(ref Guid guid, Variant* pVarVal) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public readonly int GetCustData(ref Guid guid, ref Variant pVarVal) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibStatistics(uint* pcUniqueNames, uint* pcchUniqueNames) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNames, pcchUniqueNames); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibStatistics(uint* pcUniqueNames, ref uint pcchUniqueNames) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchUniqueNamesPtr = &pcchUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNames, pcchUniqueNamesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLibStatistics(ref uint pcUniqueNames, uint* pcchUniqueNames) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcUniqueNamesPtr = &pcUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNamesPtr, pcchUniqueNames); + } + return ret; + } + + /// To be documented. + public readonly int GetLibStatistics(ref uint pcUniqueNames, ref uint pcchUniqueNames) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcUniqueNamesPtr = &pcUniqueNames) + { + fixed (uint* pcchUniqueNamesPtr = &pcchUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNamesPtr, pcchUniqueNamesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAllCustData(CustomData* pCustData) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pCustData); + return ret; + } + + /// To be documented. + public readonly int GetAllCustData(ref CustomData pCustData) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfo(uint index, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfo(index, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfoOfGuid(out ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppTinfo = default; + return @this->GetTypeInfoOfGuid(SilkMarshal.GuidPtrOf(), (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeInfoOfGuid(ref Guid guid, ref ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeInfoOfGuid(ref guid, (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public readonly int GetTypeComp(ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation(int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly int FindName(ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public readonly int FindName([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public readonly int GetDocumentation2(int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDocumentation2(int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr GetTypeInfoOfGuid() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLib2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetTypeInfoOfGuid(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistration.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistration.gen.cs new file mode 100644 index 0000000000..1c89714fc1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistration.gen.cs @@ -0,0 +1,360 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("76a3e735-02df-4a12-98eb-043ad3600af3")] + [NativeName("Name", "ITypeLibRegistration")] + public unsafe partial struct ITypeLibRegistration : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("76a3e735-02df-4a12-98eb-043ad3600af3"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeLibRegistration val) + => Unsafe.As(ref val); + + public ITypeLibRegistration + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetGuid(Guid* pGuid) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGuid); + return ret; + } + + /// To be documented. + public readonly int GetGuid(ref Guid pGuid) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pGuidPtr = &pGuid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGuidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(char** pVersion) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pVersion); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(ref char* pVersion) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pVersionPtr = &pVersion) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pVersionPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLcid(uint* pLcid) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pLcid); + return ret; + } + + /// To be documented. + public readonly int GetLcid(ref uint pLcid) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pLcidPtr = &pLcid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pLcidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWin32Path(char** pWin32Path) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pWin32Path); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWin32Path(ref char* pWin32Path) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pWin32PathPtr = &pWin32Path) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pWin32PathPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWin64Path(char** pWin64Path) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pWin64Path); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWin64Path(ref char* pWin64Path) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pWin64PathPtr = &pWin64Path) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pWin64PathPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(char** pDisplayName) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref char* pDisplayName) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pDisplayNamePtr = &pDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFlags(uint* pFlags) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pFlags); + return ret; + } + + /// To be documented. + public readonly int GetFlags(ref uint pFlags) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pFlagsPtr = &pFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pFlagsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHelpDir(char** pHelpDir) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pHelpDir); + return ret; + } + + /// To be documented. + public readonly unsafe int GetHelpDir(ref char* pHelpDir) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** pHelpDirPtr = &pHelpDir) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pHelpDirPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetVersion(string[] pVersionSa) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pVersion = (char**) SilkMarshal.StringArrayToPtr(pVersionSa); + var ret = @this->GetVersion(pVersion); + SilkMarshal.CopyPtrToStringArray((nint) pVersion, pVersionSa); + SilkMarshal.Free((nint) pVersion); + return ret; + } + + /// To be documented. + public readonly int GetWin32Path(string[] pWin32PathSa) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pWin32Path = (char**) SilkMarshal.StringArrayToPtr(pWin32PathSa); + var ret = @this->GetWin32Path(pWin32Path); + SilkMarshal.CopyPtrToStringArray((nint) pWin32Path, pWin32PathSa); + SilkMarshal.Free((nint) pWin32Path); + return ret; + } + + /// To be documented. + public readonly int GetWin64Path(string[] pWin64PathSa) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pWin64Path = (char**) SilkMarshal.StringArrayToPtr(pWin64PathSa); + var ret = @this->GetWin64Path(pWin64Path); + SilkMarshal.CopyPtrToStringArray((nint) pWin64Path, pWin64PathSa); + SilkMarshal.Free((nint) pWin64Path); + return ret; + } + + /// To be documented. + public readonly int GetDisplayName(string[] pDisplayNameSa) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pDisplayName = (char**) SilkMarshal.StringArrayToPtr(pDisplayNameSa); + var ret = @this->GetDisplayName(pDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) pDisplayName, pDisplayNameSa); + SilkMarshal.Free((nint) pDisplayName); + return ret; + } + + /// To be documented. + public readonly int GetHelpDir(string[] pHelpDirSa) + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var pHelpDir = (char**) SilkMarshal.StringArrayToPtr(pHelpDirSa); + var ret = @this->GetHelpDir(pHelpDir); + SilkMarshal.CopyPtrToStringArray((nint) pHelpDir, pHelpDirSa); + SilkMarshal.Free((nint) pHelpDir); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLibRegistration*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistrationReader.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistrationReader.gen.cs new file mode 100644 index 0000000000..c1c0090921 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeLibRegistrationReader.gen.cs @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("ed6a8a2a-b160-4e77-8f73-aa7435cd5c27")] + [NativeName("Name", "ITypeLibRegistrationReader")] + public unsafe partial struct ITypeLibRegistrationReader : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("ed6a8a2a-b160-4e77-8f73-aa7435cd5c27"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeLibRegistrationReader val) + => Unsafe.As(ref val); + + public ITypeLibRegistrationReader + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumTypeLibRegistrations(IEnumUnknown** ppEnumUnknown) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumUnknown); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumTypeLibRegistrations(ref IEnumUnknown* ppEnumUnknown) + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumUnknown** ppEnumUnknownPtr = &ppEnumUnknown) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumTypeLibRegistrations(ref ComPtr ppEnumUnknown) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumTypeLibRegistrations((IEnumUnknown**) ppEnumUnknown.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeLibRegistrationReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeMarshal.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeMarshal.gen.cs new file mode 100644 index 0000000000..79b1c7fe3b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITypeMarshal.gen.cs @@ -0,0 +1,789 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000002d-0000-0000-c000-000000000046")] + [NativeName("Name", "ITypeMarshal")] + public unsafe partial struct ITypeMarshal : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000002d-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITypeMarshal val) + => Unsafe.As(ref val); + + public ITypeMarshal + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Size(void* pvType, uint dwDestContext, void* pvDestContext, uint* pSize) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContext, pSize); + return ret; + } + + /// To be documented. + public readonly unsafe int Size(void* pvType, uint dwDestContext, void* pvDestContext, ref uint pSize) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContext, pSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Size(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContextPtr, pSize); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Size(void* pvType, uint dwDestContext, ref T0 pvDestContext, ref uint pSize) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContextPtr, pSizePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Size(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContext, pSize); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Size(ref T0 pvType, uint dwDestContext, void* pvDestContext, ref uint pSize) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContext, pSizePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Size(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint* pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, pSize); + } + } + return ret; + } + + /// To be documented. + public readonly int Size(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, ref uint pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, pSizePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Marshal(ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, uint* pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBuffer, pcbRead); + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, ref uint pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBuffer, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, uint* pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, ref uint pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(void* pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbRead) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBuffer, pcbRead); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBuffer, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + } + } + return ret; + } + + /// To be documented. + public readonly int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly int Unmarshal(ref T0 pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Free(void* pvType) + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pvType); + return ret; + } + + /// To be documented. + public readonly int Free(ref T0 pvType) where T0 : unmanaged + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pvTypePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITypeMarshal*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IdlDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IdlDesc.gen.cs new file mode 100644 index 0000000000..4d11d06145 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IdlDesc.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagIDLDESC")] + public unsafe partial struct IdlDesc + { + public IdlDesc + ( + nuint? dwReserved = null, + ushort? wIDLFlags = null + ) : this() + { + if (dwReserved is not null) + { + DwReserved = dwReserved.Value; + } + + if (wIDLFlags is not null) + { + WIDLFlags = wIDLFlags.Value; + } + } + + + [NativeName("Type", "ULONG_PTR")] + [NativeName("Type.Name", "ULONG_PTR")] + [NativeName("Name", "dwReserved")] + public nuint DwReserved; + + [NativeName("Type", "USHORT")] + [NativeName("Type.Name", "USHORT")] + [NativeName("Name", "wIDLFlags")] + public ushort WIDLFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/LICInfo.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/LICInfo.gen.cs new file mode 100644 index 0000000000..50006a8454 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/LICInfo.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagLICINFO")] + public unsafe partial struct LICInfo + { + public LICInfo + ( + int? cbLicInfo = null, + Silk.NET.Core.Bool32? fRuntimeKeyAvail = null, + Silk.NET.Core.Bool32? fLicVerified = null + ) : this() + { + if (cbLicInfo is not null) + { + CbLicInfo = cbLicInfo.Value; + } + + if (fRuntimeKeyAvail is not null) + { + FRuntimeKeyAvail = fRuntimeKeyAvail.Value; + } + + if (fLicVerified is not null) + { + FLicVerified = fLicVerified.Value; + } + } + + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "cbLicInfo")] + public int CbLicInfo; + + [NativeName("Type", "BOOL")] + [NativeName("Type.Name", "BOOL")] + [NativeName("Name", "fRuntimeKeyAvail")] + public Silk.NET.Core.Bool32 FRuntimeKeyAvail; + + [NativeName("Type", "BOOL")] + [NativeName("Type.Name", "BOOL")] + [NativeName("Name", "fLicVerified")] + public Silk.NET.Core.Bool32 FLicVerified; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/MIDLMIDLItfDocumenttarget000000020001.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/MIDLMIDLItfDocumenttarget000000020001.gen.cs index 28c1ac7195..98d3d2d21e 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/MIDLMIDLItfDocumenttarget000000020001.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/MIDLMIDLItfDocumenttarget000000020001.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "__MIDL___MIDL_itf_documenttarget_0000_0002_0001")] - public unsafe partial struct MIDLMIDLItfDocumenttarget000000020001 + public unsafe partial struct MIDLMIDLItfDocumentTarget000000020001 { - public MIDLMIDLItfDocumenttarget000000020001 + public MIDLMIDLItfDocumentTarget000000020001 ( uint? jobId = null, int? currentDocument = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ObjectWithSiteVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ObjectWithSiteVtblExtensions.gen.cs new file mode 100644 index 0000000000..d1c60833ea --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ObjectWithSiteVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ObjectWithSiteVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetSite(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkSite) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUnkSite); + return ret; + } + + /// To be documented. + public static int SetSite(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkSite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkSitePtr = &pUnkSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUnkSitePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, Guid* riid, void** ppvSite) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppvSite); + return ret; + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, Guid* riid, ref void* ppvSite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvSitePtr = &ppvSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riid, ppvSitePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, ref Guid riid, void** ppvSite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppvSite); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, ref Guid riid, ref void* ppvSite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvSitePtr = &ppvSite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, riidPtr, ppvSitePtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SetSite(this ComPtr thisVtbl, ComPtr pUnkSite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetSite((Silk.NET.Core.Native.IUnknown*) pUnkSite.Handle); + } + + /// To be documented. + public static int SetSite(this ComPtr thisVtbl, Span pUnkSite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetSite(ref pUnkSite.GetPinnableReference()); + } + + /// To be documented. + public static int GetSite(this ComPtr thisVtbl, out ComPtr ppvSite) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvSite = default; + return @this->GetSite(SilkMarshal.GuidPtrOf(), (void**) ppvSite.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, Span riid, void** ppvSite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSite(ref riid.GetPinnableReference(), ppvSite); + } + + /// To be documented. + public static unsafe int GetSite(this ComPtr thisVtbl, Span riid, ref void* ppvSite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSite(ref riid.GetPinnableReference(), ref ppvSite); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr GetSite(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetSite(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/OleParentUndoUnitVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleParentUndoUnitVtblExtensions.gen.cs new file mode 100644 index 0000000000..450f4d6850 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleParentUndoUnitVtblExtensions.gen.cs @@ -0,0 +1,449 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class OleParentUndoUnitVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Do(this ComPtr thisVtbl, IOleUndoManager* pUndoManager) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManager); + return ret; + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, ref IOleUndoManager pUndoManager) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoManager* pUndoManagerPtr = &pUndoManager) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManagerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, char** pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, ref char* pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, int* plID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plID); + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, ref int plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plIDPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, ref Guid pClsid, int* plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plID); + } + return ret; + } + + /// To be documented. + public static int GetUnitType(this ComPtr thisVtbl, ref Guid pClsid, ref int plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plIDPtr); + } + } + return ret; + } + + /// To be documented. + public static int OnNextAdd(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, IOleParentUndoUnit* pPUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pPUU); + return ret; + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, ref IOleParentUndoUnit pPUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pPUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Close(this ComPtr thisVtbl, IOleParentUndoUnit* pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pPUU, fCommit); + return ret; + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, ref IOleParentUndoUnit pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pPUUPtr, fCommit); + } + return ret; + } + + /// To be documented. + public static unsafe int Add(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUU); + return ret; + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FindUnit(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pUU); + return ret; + } + + /// To be documented. + public static int FindUnit(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetParentState(this ComPtr thisVtbl, uint* pdwState) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pdwState); + return ret; + } + + /// To be documented. + public static int GetParentState(this ComPtr thisVtbl, ref uint pdwState) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwStatePtr = &pdwState) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pdwStatePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, ComPtr pUndoManager) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Do((IOleUndoManager*) pUndoManager.Handle); + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, Span pUndoManager) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Do(ref pUndoManager.GetPinnableReference()); + } + + /// To be documented. + public static int GetDescription(this ComPtr thisVtbl, string[] pBstrSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, Span plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(pClsid, ref plID.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Span pClsid, int* plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(ref pClsid.GetPinnableReference(), plID); + } + + /// To be documented. + public static int GetUnitType(this ComPtr thisVtbl, Span pClsid, Span plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(ref pClsid.GetPinnableReference(), ref plID.GetPinnableReference()); + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, ComPtr pPUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Open((IOleParentUndoUnit*) pPUU.Handle); + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, Span pPUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Open(ref pPUU.GetPinnableReference()); + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, ComPtr pPUU, Silk.NET.Core.Bool32 fCommit) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Close((IOleParentUndoUnit*) pPUU.Handle, fCommit); + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, Span pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Close(ref pPUU.GetPinnableReference(), fCommit); + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Add((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Add(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int FindUnit(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindUnit((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int FindUnit(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindUnit(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int GetParentState(this ComPtr thisVtbl, Span pdwState) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParentState(ref pdwState.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoManagerVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoManagerVtblExtensions.gen.cs new file mode 100644 index 0000000000..30eae69d41 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoManagerVtblExtensions.gen.cs @@ -0,0 +1,505 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class OleUndoManagerVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, IOleParentUndoUnit* pPUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPUU); + return ret; + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, ref IOleParentUndoUnit pPUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Close(this ComPtr thisVtbl, IOleParentUndoUnit* pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPUU, fCommit); + return ret; + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, ref IOleParentUndoUnit pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleParentUndoUnit* pPUUPtr = &pPUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPUUPtr, fCommit); + } + return ret; + } + + /// To be documented. + public static unsafe int Add(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUU); + return ret; + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetOpenParentState(this ComPtr thisVtbl, uint* pdwState) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pdwState); + return ret; + } + + /// To be documented. + public static int GetOpenParentState(this ComPtr thisVtbl, ref uint pdwState) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwStatePtr = &pdwState) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pdwStatePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DiscardFrom(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pUU); + return ret; + } + + /// To be documented. + public static int DiscardFrom(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int UndoTo(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pUU); + return ret; + } + + /// To be documented. + public static int UndoTo(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RedoTo(this ComPtr thisVtbl, IOleUndoUnit* pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUU); + return ret; + } + + /// To be documented. + public static int RedoTo(this ComPtr thisVtbl, ref IOleUndoUnit pUU) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoUnit* pUUPtr = &pUU) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pUUPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int EnumUndoable(this ComPtr thisVtbl, IEnumOleUndoUnits** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int EnumUndoable(this ComPtr thisVtbl, ref IEnumOleUndoUnits* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int EnumRedoable(this ComPtr thisVtbl, IEnumOleUndoUnits** ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppEnum); + return ret; + } + + /// To be documented. + public static unsafe int EnumRedoable(this ComPtr thisVtbl, ref IEnumOleUndoUnits* ppEnum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumOleUndoUnits** ppEnumPtr = &ppEnum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppEnumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLastUndoDescription(this ComPtr thisVtbl, char** pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetLastUndoDescription(this ComPtr thisVtbl, ref char* pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLastRedoDescription(this ComPtr thisVtbl, char** pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetLastRedoDescription(this ComPtr thisVtbl, ref char* pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public static int Enable(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fEnable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, fEnable); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, ComPtr pPUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Open((IOleParentUndoUnit*) pPUU.Handle); + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, Span pPUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Open(ref pPUU.GetPinnableReference()); + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, ComPtr pPUU, Silk.NET.Core.Bool32 fCommit) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Close((IOleParentUndoUnit*) pPUU.Handle, fCommit); + } + + /// To be documented. + public static int Close(this ComPtr thisVtbl, Span pPUU, Silk.NET.Core.Bool32 fCommit) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Close(ref pPUU.GetPinnableReference(), fCommit); + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Add((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int Add(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Add(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int GetOpenParentState(this ComPtr thisVtbl, Span pdwState) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetOpenParentState(ref pdwState.GetPinnableReference()); + } + + /// To be documented. + public static int DiscardFrom(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->DiscardFrom((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int DiscardFrom(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DiscardFrom(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int UndoTo(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->UndoTo((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int UndoTo(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->UndoTo(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int RedoTo(this ComPtr thisVtbl, ComPtr pUU) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RedoTo((IOleUndoUnit*) pUU.Handle); + } + + /// To be documented. + public static int RedoTo(this ComPtr thisVtbl, Span pUU) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RedoTo(ref pUU.GetPinnableReference()); + } + + /// To be documented. + public static int EnumUndoable(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumUndoable((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static int EnumRedoable(this ComPtr thisVtbl, ref ComPtr ppEnum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumRedoable((IEnumOleUndoUnits**) ppEnum.GetAddressOf()); + } + + /// To be documented. + public static int GetLastUndoDescription(this ComPtr thisVtbl, string[] pBstrSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetLastUndoDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public static int GetLastRedoDescription(this ComPtr thisVtbl, string[] pBstrSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetLastRedoDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoUnitVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoUnitVtblExtensions.gen.cs new file mode 100644 index 0000000000..89d4d8f80b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/OleUndoUnitVtblExtensions.gen.cs @@ -0,0 +1,272 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class OleUndoUnitVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Do(this ComPtr thisVtbl, IOleUndoManager* pUndoManager) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManager); + return ret; + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, ref IOleUndoManager pUndoManager) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IOleUndoManager* pUndoManagerPtr = &pUndoManager) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pUndoManagerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, char** pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetDescription(this ComPtr thisVtbl, ref char* pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pBstrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, int* plID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plID); + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, ref int plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsid, plIDPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, ref Guid pClsid, int* plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plID); + } + return ret; + } + + /// To be documented. + public static int GetUnitType(this ComPtr thisVtbl, ref Guid pClsid, ref int plID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + fixed (int* plIDPtr = &plID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pClsidPtr, plIDPtr); + } + } + return ret; + } + + /// To be documented. + public static int OnNextAdd(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, ComPtr pUndoManager) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Do((IOleUndoManager*) pUndoManager.Handle); + } + + /// To be documented. + public static int Do(this ComPtr thisVtbl, Span pUndoManager) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Do(ref pUndoManager.GetPinnableReference()); + } + + /// To be documented. + public static int GetDescription(this ComPtr thisVtbl, string[] pBstrSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDescription(pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Guid* pClsid, Span plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(pClsid, ref plID.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetUnitType(this ComPtr thisVtbl, Span pClsid, int* plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(ref pClsid.GetPinnableReference(), plID); + } + + /// To be documented. + public static int GetUnitType(this ComPtr thisVtbl, Span pClsid, Span plID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetUnitType(ref pClsid.GetPinnableReference(), ref plID.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PMemoryAllocator.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PMemoryAllocator.gen.cs new file mode 100644 index 0000000000..947266eda3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PMemoryAllocator.gen.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "PMemoryAllocator")] + public unsafe partial struct PMemoryAllocator + { + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDesc.gen.cs new file mode 100644 index 0000000000..bdd800e578 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDesc.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPARAMDESC")] + public unsafe partial struct ParamDesc + { + public ParamDesc + ( + ParamDescEx* pparamdescex = null, + ushort? wParamFlags = null + ) : this() + { + if (pparamdescex is not null) + { + Pparamdescex = pparamdescex; + } + + if (wParamFlags is not null) + { + WParamFlags = wParamFlags.Value; + } + } + + + [NativeName("Type", "LPPARAMDESCEX")] + [NativeName("Type.Name", "LPPARAMDESCEX")] + [NativeName("Name", "pparamdescex")] + public ParamDescEx* Pparamdescex; + + [NativeName("Type", "USHORT")] + [NativeName("Type.Name", "USHORT")] + [NativeName("Name", "wParamFlags")] + public ushort WParamFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDescEx.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDescEx.gen.cs new file mode 100644 index 0000000000..b92327dc21 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ParamDescEx.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPARAMDESCEX")] + public unsafe partial struct ParamDescEx + { + public ParamDescEx + ( + uint? cBytes = null, + Variant? varDefaultValue = null + ) : this() + { + if (cBytes is not null) + { + CBytes = cBytes.Value; + } + + if (varDefaultValue is not null) + { + VarDefaultValue = varDefaultValue.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cBytes")] + public uint CBytes; + + [NativeName("Type", "VARIANTARG")] + [NativeName("Type.Name", "VARIANTARG")] + [NativeName("Name", "varDefaultValue")] + public Variant VarDefaultValue; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PerPropertyBrowsingVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PerPropertyBrowsingVtblExtensions.gen.cs new file mode 100644 index 0000000000..5794edfca4 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PerPropertyBrowsingVtblExtensions.gen.cs @@ -0,0 +1,284 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PerPropertyBrowsingVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayString(this ComPtr thisVtbl, int dispID, char** pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID, pBstr); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayString(this ComPtr thisVtbl, int dispID, ref char* pBstr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrPtr = &pBstr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID, pBstrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MapPropertyToPage(this ComPtr thisVtbl, int dispID, Guid* pClsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID, pClsid); + return ret; + } + + /// To be documented. + public static int MapPropertyToPage(this ComPtr thisVtbl, int dispID, ref Guid pClsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClsidPtr = &pClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID, pClsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, CALPOLESTR* pCaStringsOut, CADWORD* pCaCookiesOut) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOut, pCaCookiesOut); + return ret; + } + + /// To be documented. + public static unsafe int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, CALPOLESTR* pCaStringsOut, ref CADWORD pCaCookiesOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CADWORD* pCaCookiesOutPtr = &pCaCookiesOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOut, pCaCookiesOutPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, ref CALPOLESTR pCaStringsOut, CADWORD* pCaCookiesOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CALPOLESTR* pCaStringsOutPtr = &pCaStringsOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOutPtr, pCaCookiesOut); + } + return ret; + } + + /// To be documented. + public static int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, ref CALPOLESTR pCaStringsOut, ref CADWORD pCaCookiesOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CALPOLESTR* pCaStringsOutPtr = &pCaStringsOut) + { + fixed (CADWORD* pCaCookiesOutPtr = &pCaCookiesOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dispID, pCaStringsOutPtr, pCaCookiesOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPredefinedValue(this ComPtr thisVtbl, int dispID, uint dwCookie, Variant* pVarOut) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispID, dwCookie, pVarOut); + return ret; + } + + /// To be documented. + public static int GetPredefinedValue(this ComPtr thisVtbl, int dispID, uint dwCookie, ref Variant pVarOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarOutPtr = &pVarOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dispID, dwCookie, pVarOutPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetDisplayString(this ComPtr thisVtbl, int dispID, string[] pBstrSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstr = (char**) SilkMarshal.StringArrayToPtr(pBstrSa); + var ret = @this->GetDisplayString(dispID, pBstr); + SilkMarshal.CopyPtrToStringArray((nint) pBstr, pBstrSa); + SilkMarshal.Free((nint) pBstr); + return ret; + } + + /// To be documented. + public static int MapPropertyToPage(this ComPtr thisVtbl, int dispID, Span pClsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MapPropertyToPage(dispID, ref pClsid.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, CALPOLESTR* pCaStringsOut, Span pCaCookiesOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPredefinedStrings(dispID, pCaStringsOut, ref pCaCookiesOut.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, Span pCaStringsOut, CADWORD* pCaCookiesOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPredefinedStrings(dispID, ref pCaStringsOut.GetPinnableReference(), pCaCookiesOut); + } + + /// To be documented. + public static int GetPredefinedStrings(this ComPtr thisVtbl, int dispID, Span pCaStringsOut, Span pCaCookiesOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPredefinedStrings(dispID, ref pCaStringsOut.GetPinnableReference(), ref pCaCookiesOut.GetPinnableReference()); + } + + /// To be documented. + public static int GetPredefinedValue(this ComPtr thisVtbl, int dispID, uint dwCookie, Span pVarOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPredefinedValue(dispID, dwCookie, ref pVarOut.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistMemoryVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistMemoryVtblExtensions.gen.cs new file mode 100644 index 0000000000..3a67de4035 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistMemoryVtblExtensions.gen.cs @@ -0,0 +1,255 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistMemoryVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, void* pMem, uint cbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pMem, cbSize); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref T0 pMem, uint cbSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pMemPtr = &pMem) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pMemPtr, cbSize); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pMem, fClearDirty, cbSize); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref T0 pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pMemPtr = &pMem) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pMemPtr, fClearDirty, cbSize); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeMax(this ComPtr thisVtbl, uint* pCbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSize); + return ret; + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, ref uint pCbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pCbSizePtr = &pCbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSizePtr); + } + return ret; + } + + /// To be documented. + public static int InitNew(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pMem, uint cbSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, Span pCbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeMax(ref pCbSize.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamInitVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamInitVtblExtensions.gen.cs new file mode 100644 index 0000000000..eb6fbd8e78 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamInitVtblExtensions.gen.cs @@ -0,0 +1,271 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistStreamInitVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeMax(this ComPtr thisVtbl, ulong* pCbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSize); + return ret; + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, ref ulong pCbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pCbSizePtr = &pCbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pCbSizePtr); + } + return ret; + } + + /// To be documented. + public static int InitNew(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pStm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pStm.GetPinnableReference()); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pStm.GetPinnableReference(), fClearDirty); + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, Span pCbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeMax(ref pCbSize.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PrintDocumentPackageStatusEventVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PrintDocumentPackageStatusEventVtblExtensions.gen.cs index be864c1706..5638547ac4 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/PrintDocumentPackageStatusEventVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PrintDocumentPackageStatusEventVtblExtensions.gen.cs @@ -106,22 +106,22 @@ public static int GetTypeInfoCount(this ComPtr } /// To be documented. - public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, Silk.NET.Core.Native.IUnknown** ppTInfo) + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ITypeInfo** ppTInfo) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfo); return ret; } /// To be documented. - public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref Silk.NET.Core.Native.IUnknown* ppTInfo) + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref ITypeInfo* ppTInfo) { var @this = thisVtbl.Handle; int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppTInfoPtr = &ppTInfo) + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, iTInfo, lcid, ppTInfoPtr); } return ret; } @@ -763,22 +763,22 @@ public static int Invoke(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int PackageStatusUpdated(this ComPtr thisVtbl, MIDLMIDLItfDocumenttarget000000020001* packageStatus) + public static unsafe int PackageStatusUpdated(this ComPtr thisVtbl, MIDLMIDLItfDocumentTarget000000020001* packageStatus) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatus); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatus); return ret; } /// To be documented. - public static int PackageStatusUpdated(this ComPtr thisVtbl, ref MIDLMIDLItfDocumenttarget000000020001 packageStatus) + public static int PackageStatusUpdated(this ComPtr thisVtbl, ref MIDLMIDLItfDocumentTarget000000020001 packageStatus) { var @this = thisVtbl.Handle; int ret = default; - fixed (MIDLMIDLItfDocumenttarget000000020001* packageStatusPtr = &packageStatus) + fixed (MIDLMIDLItfDocumentTarget000000020001* packageStatusPtr = &packageStatus) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatusPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, packageStatusPtr); } return ret; } @@ -817,11 +817,11 @@ public static int GetTypeInfoCount(this ComPtr } /// To be documented. - public static int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int GetTypeInfo(this ComPtr thisVtbl, uint iTInfo, uint lcid, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader - return @this->GetTypeInfo(iTInfo, lcid, (Silk.NET.Core.Native.IUnknown**) ppTInfo.GetAddressOf()); + return @this->GetTypeInfo(iTInfo, lcid, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. @@ -1169,7 +1169,7 @@ public static int Invoke(this ComPtr thisVtbl, } /// To be documented. - public static int PackageStatusUpdated(this ComPtr thisVtbl, Span packageStatus) + public static int PackageStatusUpdated(this ComPtr thisVtbl, Span packageStatus) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropBag2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropBag2.gen.cs new file mode 100644 index 0000000000..25cbb6606d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropBag2.gen.cs @@ -0,0 +1,95 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagPROPBAG2")] + public unsafe partial struct PropBag2 + { + public PropBag2 + ( + uint? dwType = null, + ushort? vt = null, + ushort? cfType = null, + uint? dwHint = null, + char* pstrName = null, + Guid? clsid = null + ) : this() + { + if (dwType is not null) + { + DwType = dwType.Value; + } + + if (vt is not null) + { + Vt = vt.Value; + } + + if (cfType is not null) + { + CfType = cfType.Value; + } + + if (dwHint is not null) + { + DwHint = dwHint.Value; + } + + if (pstrName is not null) + { + PstrName = pstrName; + } + + if (clsid is not null) + { + Clsid = clsid.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwType")] + public uint DwType; + + [NativeName("Type", "VARTYPE")] + [NativeName("Type.Name", "VARTYPE")] + [NativeName("Name", "vt")] + public ushort Vt; + + [NativeName("Type", "CLIPFORMAT")] + [NativeName("Type.Name", "CLIPFORMAT")] + [NativeName("Name", "cfType")] + public ushort CfType; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwHint")] + public uint DwHint; + + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "pstrName")] + public char* PstrName; + + [NativeName("Type", "CLSID")] + [NativeName("Type.Name", "CLSID")] + [NativeName("Name", "clsid")] + public Guid Clsid; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpec.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpec.gen.cs new file mode 100644 index 0000000000..b36eb1c30c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpec.gen.cs @@ -0,0 +1,91 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagPROPSPEC")] + public unsafe partial struct PropSpec + { + public PropSpec + ( + uint? ulKind = null, + PropSpecUnion? anonymous = null, + uint? propid = null, + char* lpwstr = null + ) : this() + { + if (ulKind is not null) + { + UlKind = ulKind.Value; + } + + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (propid is not null) + { + Propid = propid.Value; + } + + if (lpwstr is not null) + { + Lpwstr = lpwstr; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "ulKind")] + public uint UlKind; + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_propidlbase_L452_C43")] + [NativeName("Name", "anonymous1")] + public PropSpecUnion Anonymous; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint Propid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Propid; + } +#else + public uint Propid + { + get => Anonymous.Propid; + set => Anonymous.Propid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* Lpwstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Lpwstr; + } +#else + public char* Lpwstr + { + get => Anonymous.Lpwstr; + set => Anonymous.Lpwstr = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpecUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpecUnion.gen.cs new file mode 100644 index 0000000000..88d02255e5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropSpecUnion.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] + [NativeName("Name", "__AnonymousRecord_propidlbase_L452_C43")] + public unsafe partial struct PropSpecUnion + { + public PropSpecUnion + ( + uint? propid = null, + char* lpwstr = null + ) : this() + { + if (propid is not null) + { + Propid = propid.Value; + } + + if (lpwstr is not null) + { + Lpwstr = lpwstr; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "PROPID")] + [NativeName("Type.Name", "PROPID")] + [NativeName("Name", "propid")] + public uint Propid; + + [FieldOffset(0)] + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "lpwstr")] + public char* Lpwstr; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariant.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariant.gen.cs new file mode 100644 index 0000000000..a3cde1862f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariant.gen.cs @@ -0,0 +1,1600 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagPROPVARIANT")] + public unsafe partial struct PropVariant + { + public PropVariant + ( + PropVariantUnion? anonymous = null, + TagDecimal? decVal = null, + ushort? vt = null, + ushort? wReserved1 = null, + ushort? wReserved2 = null, + ushort? wReserved3 = null, + byte? cVal = null, + byte? bVal = null, + short? iVal = null, + ushort? uiVal = null, + int? lVal = null, + uint? ulVal = null, + int? intVal = null, + uint? uintVal = null, + long? hVal = null, + ulong? uhVal = null, + float? fltVal = null, + double? dblVal = null, + short? boolVal = null, + short? oBSOLETEVARIANTBOOL = null, + int? scode = null, + CY? cyVal = null, + double? date = null, + Silk.NET.Core.Win32Extras.Filetime? filetime = null, + Guid* puuid = null, + ClipData* pclipdata = null, + char* bstrVal = null, + BSTRBlob? bstrblobVal = null, + Blob? blob = null, + byte* pszVal = null, + char* pwszVal = null, + Silk.NET.Core.Native.IUnknown* punkVal = null, + IDispatch* pdispVal = null, + Silk.NET.Core.Win32Extras.IStream* pStream = null, + IStorage* pStorage = null, + VersionedStream* pVersionedStream = null, + SafeArray* parray = null, + CAC? cac = null, + CAUB? caub = null, + CAI? cai = null, + CAUI? caui = null, + CAL? cal = null, + CAUL? caul = null, + CAH? cah = null, + CAUH? cauh = null, + CAFLT? caflt = null, + CADBL? cadbl = null, + CABool? cabool = null, + CASCode? cascode = null, + CACY? cacy = null, + CADate? cadate = null, + CAFileTime? cafiletime = null, + CACLSID? cauuid = null, + CAClipData? caclipdata = null, + CABSTR? cabstr = null, + CABSTRBlob? cabstrblob = null, + CALPSTR? calpstr = null, + CALPWSTR? calpwstr = null, + CAPropVariant? capropvar = null, + byte* pcVal = null, + byte* pbVal = null, + short* piVal = null, + ushort* puiVal = null, + int* plVal = null, + uint* pulVal = null, + int* pintVal = null, + uint* puintVal = null, + float* pfltVal = null, + double* pdblVal = null, + short* pboolVal = null, + TagDecimal* pdecVal = null, + int* pscode = null, + CY* pcyVal = null, + double* pdate = null, + char** pbstrVal = null, + Silk.NET.Core.Native.IUnknown** ppunkVal = null, + IDispatch** ppdispVal = null, + SafeArray** pparray = null, + PropVariant* pvarVal = null + ) : this() + { + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (decVal is not null) + { + DecVal = decVal.Value; + } + + if (vt is not null) + { + Vt = vt.Value; + } + + if (wReserved1 is not null) + { + WReserved1 = wReserved1.Value; + } + + if (wReserved2 is not null) + { + WReserved2 = wReserved2.Value; + } + + if (wReserved3 is not null) + { + WReserved3 = wReserved3.Value; + } + + if (cVal is not null) + { + CVal = cVal.Value; + } + + if (bVal is not null) + { + BVal = bVal.Value; + } + + if (iVal is not null) + { + IVal = iVal.Value; + } + + if (uiVal is not null) + { + UiVal = uiVal.Value; + } + + if (lVal is not null) + { + LVal = lVal.Value; + } + + if (ulVal is not null) + { + UlVal = ulVal.Value; + } + + if (intVal is not null) + { + IntVal = intVal.Value; + } + + if (uintVal is not null) + { + UintVal = uintVal.Value; + } + + if (hVal is not null) + { + HVal = hVal.Value; + } + + if (uhVal is not null) + { + UhVal = uhVal.Value; + } + + if (fltVal is not null) + { + FltVal = fltVal.Value; + } + + if (dblVal is not null) + { + DblVal = dblVal.Value; + } + + if (boolVal is not null) + { + BoolVal = boolVal.Value; + } + + if (oBSOLETEVARIANTBOOL is not null) + { + OBSOLETEVARIANTBOOL = oBSOLETEVARIANTBOOL.Value; + } + + if (scode is not null) + { + Scode = scode.Value; + } + + if (cyVal is not null) + { + CyVal = cyVal.Value; + } + + if (date is not null) + { + Date = date.Value; + } + + if (filetime is not null) + { + Filetime = filetime.Value; + } + + if (puuid is not null) + { + Puuid = puuid; + } + + if (pclipdata is not null) + { + Pclipdata = pclipdata; + } + + if (bstrVal is not null) + { + BstrVal = bstrVal; + } + + if (bstrblobVal is not null) + { + BstrblobVal = bstrblobVal.Value; + } + + if (blob is not null) + { + Blob = blob.Value; + } + + if (pszVal is not null) + { + PszVal = pszVal; + } + + if (pwszVal is not null) + { + PwszVal = pwszVal; + } + + if (punkVal is not null) + { + PunkVal = punkVal; + } + + if (pdispVal is not null) + { + PdispVal = pdispVal; + } + + if (pStream is not null) + { + PStream = pStream; + } + + if (pStorage is not null) + { + PStorage = pStorage; + } + + if (pVersionedStream is not null) + { + PVersionedStream = pVersionedStream; + } + + if (parray is not null) + { + Parray = parray; + } + + if (cac is not null) + { + Cac = cac.Value; + } + + if (caub is not null) + { + Caub = caub.Value; + } + + if (cai is not null) + { + Cai = cai.Value; + } + + if (caui is not null) + { + Caui = caui.Value; + } + + if (cal is not null) + { + Cal = cal.Value; + } + + if (caul is not null) + { + Caul = caul.Value; + } + + if (cah is not null) + { + Cah = cah.Value; + } + + if (cauh is not null) + { + Cauh = cauh.Value; + } + + if (caflt is not null) + { + Caflt = caflt.Value; + } + + if (cadbl is not null) + { + Cadbl = cadbl.Value; + } + + if (cabool is not null) + { + Cabool = cabool.Value; + } + + if (cascode is not null) + { + Cascode = cascode.Value; + } + + if (cacy is not null) + { + Cacy = cacy.Value; + } + + if (cadate is not null) + { + Cadate = cadate.Value; + } + + if (cafiletime is not null) + { + Cafiletime = cafiletime.Value; + } + + if (cauuid is not null) + { + Cauuid = cauuid.Value; + } + + if (caclipdata is not null) + { + Caclipdata = caclipdata.Value; + } + + if (cabstr is not null) + { + Cabstr = cabstr.Value; + } + + if (cabstrblob is not null) + { + Cabstrblob = cabstrblob.Value; + } + + if (calpstr is not null) + { + Calpstr = calpstr.Value; + } + + if (calpwstr is not null) + { + Calpwstr = calpwstr.Value; + } + + if (capropvar is not null) + { + Capropvar = capropvar.Value; + } + + if (pcVal is not null) + { + PcVal = pcVal; + } + + if (pbVal is not null) + { + PbVal = pbVal; + } + + if (piVal is not null) + { + PiVal = piVal; + } + + if (puiVal is not null) + { + PuiVal = puiVal; + } + + if (plVal is not null) + { + PlVal = plVal; + } + + if (pulVal is not null) + { + PulVal = pulVal; + } + + if (pintVal is not null) + { + PintVal = pintVal; + } + + if (puintVal is not null) + { + PuintVal = puintVal; + } + + if (pfltVal is not null) + { + PfltVal = pfltVal; + } + + if (pdblVal is not null) + { + PdblVal = pdblVal; + } + + if (pboolVal is not null) + { + PboolVal = pboolVal; + } + + if (pdecVal is not null) + { + PdecVal = pdecVal; + } + + if (pscode is not null) + { + Pscode = pscode; + } + + if (pcyVal is not null) + { + PcyVal = pcyVal; + } + + if (pdate is not null) + { + Pdate = pdate; + } + + if (pbstrVal is not null) + { + PbstrVal = pbstrVal; + } + + if (ppunkVal is not null) + { + PpunkVal = ppunkVal; + } + + if (ppdispVal is not null) + { + PpdispVal = ppdispVal; + } + + if (pparray is not null) + { + Pparray = pparray; + } + + if (pvarVal is not null) + { + PvarVal = pvarVal; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_propidlbase_L303_C3")] + [NativeName("Name", "anonymous1")] + public PropVariantUnion Anonymous; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref TagDecimal DecVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].DecVal; + } +#else + public TagDecimal DecVal + { + get => Anonymous.DecVal; + set => Anonymous.DecVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort Vt + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Vt; + } +#else + public ushort Vt + { + get => Anonymous.Vt; + set => Anonymous.Vt = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved1 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved1; + } +#else + public ushort WReserved1 + { + get => Anonymous.WReserved1; + set => Anonymous.WReserved1 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved2 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved2; + } +#else + public ushort WReserved2 + { + get => Anonymous.WReserved2; + set => Anonymous.WReserved2 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved3 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved3; + } +#else + public ushort WReserved3 + { + get => Anonymous.WReserved3; + set => Anonymous.WReserved3 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte CVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CVal; + } +#else + public byte CVal + { + get => Anonymous.CVal; + set => Anonymous.CVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte BVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BVal; + } +#else + public byte BVal + { + get => Anonymous.BVal; + set => Anonymous.BVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short IVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IVal; + } +#else + public short IVal + { + get => Anonymous.IVal; + set => Anonymous.IVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort UiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UiVal; + } +#else + public ushort UiVal + { + get => Anonymous.UiVal; + set => Anonymous.UiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int LVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].LVal; + } +#else + public int LVal + { + get => Anonymous.LVal; + set => Anonymous.LVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UlVal; + } +#else + public uint UlVal + { + get => Anonymous.UlVal; + set => Anonymous.UlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int IntVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IntVal; + } +#else + public int IntVal + { + get => Anonymous.IntVal; + set => Anonymous.IntVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UintVal; + } +#else + public uint UintVal + { + get => Anonymous.UintVal; + set => Anonymous.UintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref long HVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HVal; + } +#else + public long HVal + { + get => Anonymous.HVal; + set => Anonymous.HVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ulong UhVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UhVal; + } +#else + public ulong UhVal + { + get => Anonymous.UhVal; + set => Anonymous.UhVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float FltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].FltVal; + } +#else + public float FltVal + { + get => Anonymous.FltVal; + set => Anonymous.FltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double DblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].DblVal; + } +#else + public double DblVal + { + get => Anonymous.DblVal; + set => Anonymous.DblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short BoolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BoolVal; + } +#else + public short BoolVal + { + get => Anonymous.BoolVal; + set => Anonymous.BoolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short OBSOLETEVARIANTBOOL + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].OBSOLETEVARIANTBOOL; + } +#else + public short OBSOLETEVARIANTBOOL + { + get => Anonymous.OBSOLETEVARIANTBOOL; + set => Anonymous.OBSOLETEVARIANTBOOL = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int Scode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Scode; + } +#else + public int Scode + { + get => Anonymous.Scode; + set => Anonymous.Scode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY CyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CyVal; + } +#else + public CY CyVal + { + get => Anonymous.CyVal; + set => Anonymous.CyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double Date + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Date; + } +#else + public double Date + { + get => Anonymous.Date; + set => Anonymous.Date = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.Filetime Filetime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Filetime; + } +#else + public Silk.NET.Core.Win32Extras.Filetime Filetime + { + get => Anonymous.Filetime; + set => Anonymous.Filetime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Guid* Puuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Puuid; + } +#else + public Guid* Puuid + { + get => Anonymous.Puuid; + set => Anonymous.Puuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ClipData* Pclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pclipdata; + } +#else + public ClipData* Pclipdata + { + get => Anonymous.Pclipdata; + set => Anonymous.Pclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* BstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrVal; + } +#else + public char* BstrVal + { + get => Anonymous.BstrVal; + set => Anonymous.BstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref BSTRBlob BstrblobVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrblobVal; + } +#else + public BSTRBlob BstrblobVal + { + get => Anonymous.BstrblobVal; + set => Anonymous.BstrblobVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Blob Blob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Blob; + } +#else + public Blob Blob + { + get => Anonymous.Blob; + set => Anonymous.Blob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PszVal; + } +#else + public byte* PszVal + { + get => Anonymous.PszVal; + set => Anonymous.PszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* PwszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PwszVal; + } +#else + public char* PwszVal + { + get => Anonymous.PwszVal; + set => Anonymous.PwszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown* PunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown* PunkVal + { + get => Anonymous.PunkVal; + set => Anonymous.PunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch* PdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdispVal; + } +#else + public IDispatch* PdispVal + { + get => Anonymous.PdispVal; + set => Anonymous.PdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.IStream* PStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStream; + } +#else + public Silk.NET.Core.Win32Extras.IStream* PStream + { + get => Anonymous.PStream; + set => Anonymous.PStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IStorage* PStorage + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStorage; + } +#else + public IStorage* PStorage + { + get => Anonymous.PStorage; + set => Anonymous.PStorage = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref VersionedStream* PVersionedStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PVersionedStream; + } +#else + public VersionedStream* PVersionedStream + { + get => Anonymous.PVersionedStream; + set => Anonymous.PVersionedStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray* Parray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Parray; + } +#else + public SafeArray* Parray + { + get => Anonymous.Parray; + set => Anonymous.Parray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAC Cac + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cac; + } +#else + public CAC Cac + { + get => Anonymous.Cac; + set => Anonymous.Cac = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUB Caub + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caub; + } +#else + public CAUB Caub + { + get => Anonymous.Caub; + set => Anonymous.Caub = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAI Cai + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cai; + } +#else + public CAI Cai + { + get => Anonymous.Cai; + set => Anonymous.Cai = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUI Caui + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caui; + } +#else + public CAUI Caui + { + get => Anonymous.Caui; + set => Anonymous.Caui = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAL Cal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cal; + } +#else + public CAL Cal + { + get => Anonymous.Cal; + set => Anonymous.Cal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUL Caul + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caul; + } +#else + public CAUL Caul + { + get => Anonymous.Caul; + set => Anonymous.Caul = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAH Cah + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cah; + } +#else + public CAH Cah + { + get => Anonymous.Cah; + set => Anonymous.Cah = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUH Cauh + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauh; + } +#else + public CAUH Cauh + { + get => Anonymous.Cauh; + set => Anonymous.Cauh = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFLT Caflt + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caflt; + } +#else + public CAFLT Caflt + { + get => Anonymous.Caflt; + set => Anonymous.Caflt = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADBL Cadbl + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadbl; + } +#else + public CADBL Cadbl + { + get => Anonymous.Cadbl; + set => Anonymous.Cadbl = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABool Cabool + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabool; + } +#else + public CABool Cabool + { + get => Anonymous.Cabool; + set => Anonymous.Cabool = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CASCode Cascode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cascode; + } +#else + public CASCode Cascode + { + get => Anonymous.Cascode; + set => Anonymous.Cascode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACY Cacy + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cacy; + } +#else + public CACY Cacy + { + get => Anonymous.Cacy; + set => Anonymous.Cacy = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADate Cadate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadate; + } +#else + public CADate Cadate + { + get => Anonymous.Cadate; + set => Anonymous.Cadate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFileTime Cafiletime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cafiletime; + } +#else + public CAFileTime Cafiletime + { + get => Anonymous.Cafiletime; + set => Anonymous.Cafiletime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACLSID Cauuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauuid; + } +#else + public CACLSID Cauuid + { + get => Anonymous.Cauuid; + set => Anonymous.Cauuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAClipData Caclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caclipdata; + } +#else + public CAClipData Caclipdata + { + get => Anonymous.Caclipdata; + set => Anonymous.Caclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTR Cabstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstr; + } +#else + public CABSTR Cabstr + { + get => Anonymous.Cabstr; + set => Anonymous.Cabstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTRBlob Cabstrblob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstrblob; + } +#else + public CABSTRBlob Cabstrblob + { + get => Anonymous.Cabstrblob; + set => Anonymous.Cabstrblob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPSTR Calpstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpstr; + } +#else + public CALPSTR Calpstr + { + get => Anonymous.Calpstr; + set => Anonymous.Calpstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPWSTR Calpwstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpwstr; + } +#else + public CALPWSTR Calpwstr + { + get => Anonymous.Calpwstr; + set => Anonymous.Calpwstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAPropVariant Capropvar + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Capropvar; + } +#else + public CAPropVariant Capropvar + { + get => Anonymous.Capropvar; + set => Anonymous.Capropvar = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PcVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcVal; + } +#else + public byte* PcVal + { + get => Anonymous.PcVal; + set => Anonymous.PcVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PbVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbVal; + } +#else + public byte* PbVal + { + get => Anonymous.PbVal; + set => Anonymous.PbVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PiVal; + } +#else + public short* PiVal + { + get => Anonymous.PiVal; + set => Anonymous.PiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort* PuiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuiVal; + } +#else + public ushort* PuiVal + { + get => Anonymous.PuiVal; + set => Anonymous.PuiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PlVal; + } +#else + public int* PlVal + { + get => Anonymous.PlVal; + set => Anonymous.PlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PulVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PulVal; + } +#else + public uint* PulVal + { + get => Anonymous.PulVal; + set => Anonymous.PulVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PintVal; + } +#else + public int* PintVal + { + get => Anonymous.PintVal; + set => Anonymous.PintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PuintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuintVal; + } +#else + public uint* PuintVal + { + get => Anonymous.PuintVal; + set => Anonymous.PuintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float* PfltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PfltVal; + } +#else + public float* PfltVal + { + get => Anonymous.PfltVal; + set => Anonymous.PfltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* PdblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdblVal; + } +#else + public double* PdblVal + { + get => Anonymous.PdblVal; + set => Anonymous.PdblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PboolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PboolVal; + } +#else + public short* PboolVal + { + get => Anonymous.PboolVal; + set => Anonymous.PboolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref TagDecimal* PdecVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdecVal; + } +#else + public TagDecimal* PdecVal + { + get => Anonymous.PdecVal; + set => Anonymous.PdecVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* Pscode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pscode; + } +#else + public int* Pscode + { + get => Anonymous.Pscode; + set => Anonymous.Pscode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY* PcyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcyVal; + } +#else + public CY* PcyVal + { + get => Anonymous.PcyVal; + set => Anonymous.PcyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* Pdate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pdate; + } +#else + public double* Pdate + { + get => Anonymous.Pdate; + set => Anonymous.Pdate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char** PbstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbstrVal; + } +#else + public char** PbstrVal + { + get => Anonymous.PbstrVal; + set => Anonymous.PbstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown** PpunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown** PpunkVal + { + get => Anonymous.PpunkVal; + set => Anonymous.PpunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch** PpdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpdispVal; + } +#else + public IDispatch** PpdispVal + { + get => Anonymous.PpdispVal; + set => Anonymous.PpdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray** Pparray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pparray; + } +#else + public SafeArray** Pparray + { + get => Anonymous.Pparray; + set => Anonymous.Pparray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref PropVariant* PvarVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PvarVal; + } +#else + public PropVariant* PvarVal + { + get => Anonymous.PvarVal; + set => Anonymous.PvarVal = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnion.gen.cs new file mode 100644 index 0000000000..ec4fc98b66 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnion.gen.cs @@ -0,0 +1,1593 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] + [NativeName("Name", "__AnonymousRecord_propidlbase_L303_C3")] + public unsafe partial struct PropVariantUnion + { + public PropVariantUnion + ( + PropVariantUnionUnion? anonymous = null, + TagDecimal? decVal = null, + ushort? vt = null, + ushort? wReserved1 = null, + ushort? wReserved2 = null, + ushort? wReserved3 = null, + byte? cVal = null, + byte? bVal = null, + short? iVal = null, + ushort? uiVal = null, + int? lVal = null, + uint? ulVal = null, + int? intVal = null, + uint? uintVal = null, + long? hVal = null, + ulong? uhVal = null, + float? fltVal = null, + double? dblVal = null, + short? boolVal = null, + short? oBSOLETEVARIANTBOOL = null, + int? scode = null, + CY? cyVal = null, + double? date = null, + Silk.NET.Core.Win32Extras.Filetime? filetime = null, + Guid* puuid = null, + ClipData* pclipdata = null, + char* bstrVal = null, + BSTRBlob? bstrblobVal = null, + Blob? blob = null, + byte* pszVal = null, + char* pwszVal = null, + Silk.NET.Core.Native.IUnknown* punkVal = null, + IDispatch* pdispVal = null, + Silk.NET.Core.Win32Extras.IStream* pStream = null, + IStorage* pStorage = null, + VersionedStream* pVersionedStream = null, + SafeArray* parray = null, + CAC? cac = null, + CAUB? caub = null, + CAI? cai = null, + CAUI? caui = null, + CAL? cal = null, + CAUL? caul = null, + CAH? cah = null, + CAUH? cauh = null, + CAFLT? caflt = null, + CADBL? cadbl = null, + CABool? cabool = null, + CASCode? cascode = null, + CACY? cacy = null, + CADate? cadate = null, + CAFileTime? cafiletime = null, + CACLSID? cauuid = null, + CAClipData? caclipdata = null, + CABSTR? cabstr = null, + CABSTRBlob? cabstrblob = null, + CALPSTR? calpstr = null, + CALPWSTR? calpwstr = null, + CAPropVariant? capropvar = null, + byte* pcVal = null, + byte* pbVal = null, + short* piVal = null, + ushort* puiVal = null, + int* plVal = null, + uint* pulVal = null, + int* pintVal = null, + uint* puintVal = null, + float* pfltVal = null, + double* pdblVal = null, + short* pboolVal = null, + TagDecimal* pdecVal = null, + int* pscode = null, + CY* pcyVal = null, + double* pdate = null, + char** pbstrVal = null, + Silk.NET.Core.Native.IUnknown** ppunkVal = null, + IDispatch** ppdispVal = null, + SafeArray** pparray = null, + PropVariant* pvarVal = null + ) : this() + { + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (decVal is not null) + { + DecVal = decVal.Value; + } + + if (vt is not null) + { + Vt = vt.Value; + } + + if (wReserved1 is not null) + { + WReserved1 = wReserved1.Value; + } + + if (wReserved2 is not null) + { + WReserved2 = wReserved2.Value; + } + + if (wReserved3 is not null) + { + WReserved3 = wReserved3.Value; + } + + if (cVal is not null) + { + CVal = cVal.Value; + } + + if (bVal is not null) + { + BVal = bVal.Value; + } + + if (iVal is not null) + { + IVal = iVal.Value; + } + + if (uiVal is not null) + { + UiVal = uiVal.Value; + } + + if (lVal is not null) + { + LVal = lVal.Value; + } + + if (ulVal is not null) + { + UlVal = ulVal.Value; + } + + if (intVal is not null) + { + IntVal = intVal.Value; + } + + if (uintVal is not null) + { + UintVal = uintVal.Value; + } + + if (hVal is not null) + { + HVal = hVal.Value; + } + + if (uhVal is not null) + { + UhVal = uhVal.Value; + } + + if (fltVal is not null) + { + FltVal = fltVal.Value; + } + + if (dblVal is not null) + { + DblVal = dblVal.Value; + } + + if (boolVal is not null) + { + BoolVal = boolVal.Value; + } + + if (oBSOLETEVARIANTBOOL is not null) + { + OBSOLETEVARIANTBOOL = oBSOLETEVARIANTBOOL.Value; + } + + if (scode is not null) + { + Scode = scode.Value; + } + + if (cyVal is not null) + { + CyVal = cyVal.Value; + } + + if (date is not null) + { + Date = date.Value; + } + + if (filetime is not null) + { + Filetime = filetime.Value; + } + + if (puuid is not null) + { + Puuid = puuid; + } + + if (pclipdata is not null) + { + Pclipdata = pclipdata; + } + + if (bstrVal is not null) + { + BstrVal = bstrVal; + } + + if (bstrblobVal is not null) + { + BstrblobVal = bstrblobVal.Value; + } + + if (blob is not null) + { + Blob = blob.Value; + } + + if (pszVal is not null) + { + PszVal = pszVal; + } + + if (pwszVal is not null) + { + PwszVal = pwszVal; + } + + if (punkVal is not null) + { + PunkVal = punkVal; + } + + if (pdispVal is not null) + { + PdispVal = pdispVal; + } + + if (pStream is not null) + { + PStream = pStream; + } + + if (pStorage is not null) + { + PStorage = pStorage; + } + + if (pVersionedStream is not null) + { + PVersionedStream = pVersionedStream; + } + + if (parray is not null) + { + Parray = parray; + } + + if (cac is not null) + { + Cac = cac.Value; + } + + if (caub is not null) + { + Caub = caub.Value; + } + + if (cai is not null) + { + Cai = cai.Value; + } + + if (caui is not null) + { + Caui = caui.Value; + } + + if (cal is not null) + { + Cal = cal.Value; + } + + if (caul is not null) + { + Caul = caul.Value; + } + + if (cah is not null) + { + Cah = cah.Value; + } + + if (cauh is not null) + { + Cauh = cauh.Value; + } + + if (caflt is not null) + { + Caflt = caflt.Value; + } + + if (cadbl is not null) + { + Cadbl = cadbl.Value; + } + + if (cabool is not null) + { + Cabool = cabool.Value; + } + + if (cascode is not null) + { + Cascode = cascode.Value; + } + + if (cacy is not null) + { + Cacy = cacy.Value; + } + + if (cadate is not null) + { + Cadate = cadate.Value; + } + + if (cafiletime is not null) + { + Cafiletime = cafiletime.Value; + } + + if (cauuid is not null) + { + Cauuid = cauuid.Value; + } + + if (caclipdata is not null) + { + Caclipdata = caclipdata.Value; + } + + if (cabstr is not null) + { + Cabstr = cabstr.Value; + } + + if (cabstrblob is not null) + { + Cabstrblob = cabstrblob.Value; + } + + if (calpstr is not null) + { + Calpstr = calpstr.Value; + } + + if (calpwstr is not null) + { + Calpwstr = calpwstr.Value; + } + + if (capropvar is not null) + { + Capropvar = capropvar.Value; + } + + if (pcVal is not null) + { + PcVal = pcVal; + } + + if (pbVal is not null) + { + PbVal = pbVal; + } + + if (piVal is not null) + { + PiVal = piVal; + } + + if (puiVal is not null) + { + PuiVal = puiVal; + } + + if (plVal is not null) + { + PlVal = plVal; + } + + if (pulVal is not null) + { + PulVal = pulVal; + } + + if (pintVal is not null) + { + PintVal = pintVal; + } + + if (puintVal is not null) + { + PuintVal = puintVal; + } + + if (pfltVal is not null) + { + PfltVal = pfltVal; + } + + if (pdblVal is not null) + { + PdblVal = pdblVal; + } + + if (pboolVal is not null) + { + PboolVal = pboolVal; + } + + if (pdecVal is not null) + { + PdecVal = pdecVal; + } + + if (pscode is not null) + { + Pscode = pscode; + } + + if (pcyVal is not null) + { + PcyVal = pcyVal; + } + + if (pdate is not null) + { + Pdate = pdate; + } + + if (pbstrVal is not null) + { + PbstrVal = pbstrVal; + } + + if (ppunkVal is not null) + { + PpunkVal = ppunkVal; + } + + if (ppdispVal is not null) + { + PpdispVal = ppdispVal; + } + + if (pparray is not null) + { + Pparray = pparray; + } + + if (pvarVal is not null) + { + PvarVal = pvarVal; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_propidlbase_L305_C1")] + [NativeName("Name", "anonymous1")] + public PropVariantUnionUnion Anonymous; + + [FieldOffset(0)] + [NativeName("Type", "DECIMAL")] + [NativeName("Type.Name", "DECIMAL")] + [NativeName("Name", "decVal")] + public TagDecimal DecVal; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort Vt + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Vt; + } +#else + public ushort Vt + { + get => Anonymous.Vt; + set => Anonymous.Vt = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved1 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved1; + } +#else + public ushort WReserved1 + { + get => Anonymous.WReserved1; + set => Anonymous.WReserved1 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved2 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved2; + } +#else + public ushort WReserved2 + { + get => Anonymous.WReserved2; + set => Anonymous.WReserved2 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort WReserved3 + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].WReserved3; + } +#else + public ushort WReserved3 + { + get => Anonymous.WReserved3; + set => Anonymous.WReserved3 = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte CVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CVal; + } +#else + public byte CVal + { + get => Anonymous.CVal; + set => Anonymous.CVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte BVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BVal; + } +#else + public byte BVal + { + get => Anonymous.BVal; + set => Anonymous.BVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short IVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IVal; + } +#else + public short IVal + { + get => Anonymous.IVal; + set => Anonymous.IVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort UiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UiVal; + } +#else + public ushort UiVal + { + get => Anonymous.UiVal; + set => Anonymous.UiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int LVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].LVal; + } +#else + public int LVal + { + get => Anonymous.LVal; + set => Anonymous.LVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UlVal; + } +#else + public uint UlVal + { + get => Anonymous.UlVal; + set => Anonymous.UlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int IntVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IntVal; + } +#else + public int IntVal + { + get => Anonymous.IntVal; + set => Anonymous.IntVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UintVal; + } +#else + public uint UintVal + { + get => Anonymous.UintVal; + set => Anonymous.UintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref long HVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HVal; + } +#else + public long HVal + { + get => Anonymous.HVal; + set => Anonymous.HVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ulong UhVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UhVal; + } +#else + public ulong UhVal + { + get => Anonymous.UhVal; + set => Anonymous.UhVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float FltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].FltVal; + } +#else + public float FltVal + { + get => Anonymous.FltVal; + set => Anonymous.FltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double DblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].DblVal; + } +#else + public double DblVal + { + get => Anonymous.DblVal; + set => Anonymous.DblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short BoolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BoolVal; + } +#else + public short BoolVal + { + get => Anonymous.BoolVal; + set => Anonymous.BoolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short OBSOLETEVARIANTBOOL + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].OBSOLETEVARIANTBOOL; + } +#else + public short OBSOLETEVARIANTBOOL + { + get => Anonymous.OBSOLETEVARIANTBOOL; + set => Anonymous.OBSOLETEVARIANTBOOL = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int Scode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Scode; + } +#else + public int Scode + { + get => Anonymous.Scode; + set => Anonymous.Scode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY CyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CyVal; + } +#else + public CY CyVal + { + get => Anonymous.CyVal; + set => Anonymous.CyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double Date + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Date; + } +#else + public double Date + { + get => Anonymous.Date; + set => Anonymous.Date = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.Filetime Filetime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Filetime; + } +#else + public Silk.NET.Core.Win32Extras.Filetime Filetime + { + get => Anonymous.Filetime; + set => Anonymous.Filetime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Guid* Puuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Puuid; + } +#else + public Guid* Puuid + { + get => Anonymous.Puuid; + set => Anonymous.Puuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ClipData* Pclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pclipdata; + } +#else + public ClipData* Pclipdata + { + get => Anonymous.Pclipdata; + set => Anonymous.Pclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* BstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrVal; + } +#else + public char* BstrVal + { + get => Anonymous.BstrVal; + set => Anonymous.BstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref BSTRBlob BstrblobVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrblobVal; + } +#else + public BSTRBlob BstrblobVal + { + get => Anonymous.BstrblobVal; + set => Anonymous.BstrblobVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Blob Blob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Blob; + } +#else + public Blob Blob + { + get => Anonymous.Blob; + set => Anonymous.Blob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PszVal; + } +#else + public byte* PszVal + { + get => Anonymous.PszVal; + set => Anonymous.PszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* PwszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PwszVal; + } +#else + public char* PwszVal + { + get => Anonymous.PwszVal; + set => Anonymous.PwszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown* PunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown* PunkVal + { + get => Anonymous.PunkVal; + set => Anonymous.PunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch* PdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdispVal; + } +#else + public IDispatch* PdispVal + { + get => Anonymous.PdispVal; + set => Anonymous.PdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.IStream* PStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStream; + } +#else + public Silk.NET.Core.Win32Extras.IStream* PStream + { + get => Anonymous.PStream; + set => Anonymous.PStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IStorage* PStorage + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStorage; + } +#else + public IStorage* PStorage + { + get => Anonymous.PStorage; + set => Anonymous.PStorage = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref VersionedStream* PVersionedStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PVersionedStream; + } +#else + public VersionedStream* PVersionedStream + { + get => Anonymous.PVersionedStream; + set => Anonymous.PVersionedStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray* Parray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Parray; + } +#else + public SafeArray* Parray + { + get => Anonymous.Parray; + set => Anonymous.Parray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAC Cac + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cac; + } +#else + public CAC Cac + { + get => Anonymous.Cac; + set => Anonymous.Cac = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUB Caub + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caub; + } +#else + public CAUB Caub + { + get => Anonymous.Caub; + set => Anonymous.Caub = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAI Cai + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cai; + } +#else + public CAI Cai + { + get => Anonymous.Cai; + set => Anonymous.Cai = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUI Caui + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caui; + } +#else + public CAUI Caui + { + get => Anonymous.Caui; + set => Anonymous.Caui = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAL Cal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cal; + } +#else + public CAL Cal + { + get => Anonymous.Cal; + set => Anonymous.Cal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUL Caul + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caul; + } +#else + public CAUL Caul + { + get => Anonymous.Caul; + set => Anonymous.Caul = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAH Cah + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cah; + } +#else + public CAH Cah + { + get => Anonymous.Cah; + set => Anonymous.Cah = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUH Cauh + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauh; + } +#else + public CAUH Cauh + { + get => Anonymous.Cauh; + set => Anonymous.Cauh = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFLT Caflt + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caflt; + } +#else + public CAFLT Caflt + { + get => Anonymous.Caflt; + set => Anonymous.Caflt = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADBL Cadbl + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadbl; + } +#else + public CADBL Cadbl + { + get => Anonymous.Cadbl; + set => Anonymous.Cadbl = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABool Cabool + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabool; + } +#else + public CABool Cabool + { + get => Anonymous.Cabool; + set => Anonymous.Cabool = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CASCode Cascode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cascode; + } +#else + public CASCode Cascode + { + get => Anonymous.Cascode; + set => Anonymous.Cascode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACY Cacy + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cacy; + } +#else + public CACY Cacy + { + get => Anonymous.Cacy; + set => Anonymous.Cacy = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADate Cadate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadate; + } +#else + public CADate Cadate + { + get => Anonymous.Cadate; + set => Anonymous.Cadate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFileTime Cafiletime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cafiletime; + } +#else + public CAFileTime Cafiletime + { + get => Anonymous.Cafiletime; + set => Anonymous.Cafiletime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACLSID Cauuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauuid; + } +#else + public CACLSID Cauuid + { + get => Anonymous.Cauuid; + set => Anonymous.Cauuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAClipData Caclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caclipdata; + } +#else + public CAClipData Caclipdata + { + get => Anonymous.Caclipdata; + set => Anonymous.Caclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTR Cabstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstr; + } +#else + public CABSTR Cabstr + { + get => Anonymous.Cabstr; + set => Anonymous.Cabstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTRBlob Cabstrblob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstrblob; + } +#else + public CABSTRBlob Cabstrblob + { + get => Anonymous.Cabstrblob; + set => Anonymous.Cabstrblob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPSTR Calpstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpstr; + } +#else + public CALPSTR Calpstr + { + get => Anonymous.Calpstr; + set => Anonymous.Calpstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPWSTR Calpwstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpwstr; + } +#else + public CALPWSTR Calpwstr + { + get => Anonymous.Calpwstr; + set => Anonymous.Calpwstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAPropVariant Capropvar + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Capropvar; + } +#else + public CAPropVariant Capropvar + { + get => Anonymous.Capropvar; + set => Anonymous.Capropvar = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PcVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcVal; + } +#else + public byte* PcVal + { + get => Anonymous.PcVal; + set => Anonymous.PcVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PbVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbVal; + } +#else + public byte* PbVal + { + get => Anonymous.PbVal; + set => Anonymous.PbVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PiVal; + } +#else + public short* PiVal + { + get => Anonymous.PiVal; + set => Anonymous.PiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort* PuiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuiVal; + } +#else + public ushort* PuiVal + { + get => Anonymous.PuiVal; + set => Anonymous.PuiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PlVal; + } +#else + public int* PlVal + { + get => Anonymous.PlVal; + set => Anonymous.PlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PulVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PulVal; + } +#else + public uint* PulVal + { + get => Anonymous.PulVal; + set => Anonymous.PulVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PintVal; + } +#else + public int* PintVal + { + get => Anonymous.PintVal; + set => Anonymous.PintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PuintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuintVal; + } +#else + public uint* PuintVal + { + get => Anonymous.PuintVal; + set => Anonymous.PuintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float* PfltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PfltVal; + } +#else + public float* PfltVal + { + get => Anonymous.PfltVal; + set => Anonymous.PfltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* PdblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdblVal; + } +#else + public double* PdblVal + { + get => Anonymous.PdblVal; + set => Anonymous.PdblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PboolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PboolVal; + } +#else + public short* PboolVal + { + get => Anonymous.PboolVal; + set => Anonymous.PboolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref TagDecimal* PdecVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdecVal; + } +#else + public TagDecimal* PdecVal + { + get => Anonymous.PdecVal; + set => Anonymous.PdecVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* Pscode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pscode; + } +#else + public int* Pscode + { + get => Anonymous.Pscode; + set => Anonymous.Pscode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY* PcyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcyVal; + } +#else + public CY* PcyVal + { + get => Anonymous.PcyVal; + set => Anonymous.PcyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* Pdate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pdate; + } +#else + public double* Pdate + { + get => Anonymous.Pdate; + set => Anonymous.Pdate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char** PbstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbstrVal; + } +#else + public char** PbstrVal + { + get => Anonymous.PbstrVal; + set => Anonymous.PbstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown** PpunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown** PpunkVal + { + get => Anonymous.PpunkVal; + set => Anonymous.PpunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch** PpdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpdispVal; + } +#else + public IDispatch** PpdispVal + { + get => Anonymous.PpdispVal; + set => Anonymous.PpdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray** Pparray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pparray; + } +#else + public SafeArray** Pparray + { + get => Anonymous.Pparray; + set => Anonymous.Pparray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref PropVariant* PvarVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PvarVal; + } +#else + public PropVariant* PvarVal + { + get => Anonymous.PvarVal; + set => Anonymous.PvarVal = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnion.gen.cs new file mode 100644 index 0000000000..d2eff9fbaf --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnion.gen.cs @@ -0,0 +1,1544 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "__AnonymousRecord_propidlbase_L305_C1")] + public unsafe partial struct PropVariantUnionUnion + { + public PropVariantUnionUnion + ( + ushort? vt = null, + ushort? wReserved1 = null, + ushort? wReserved2 = null, + ushort? wReserved3 = null, + PropVariantUnionUnionUnion? anonymous = null, + byte? cVal = null, + byte? bVal = null, + short? iVal = null, + ushort? uiVal = null, + int? lVal = null, + uint? ulVal = null, + int? intVal = null, + uint? uintVal = null, + long? hVal = null, + ulong? uhVal = null, + float? fltVal = null, + double? dblVal = null, + short? boolVal = null, + short? oBSOLETEVARIANTBOOL = null, + int? scode = null, + CY? cyVal = null, + double? date = null, + Silk.NET.Core.Win32Extras.Filetime? filetime = null, + Guid* puuid = null, + ClipData* pclipdata = null, + char* bstrVal = null, + BSTRBlob? bstrblobVal = null, + Blob? blob = null, + byte* pszVal = null, + char* pwszVal = null, + Silk.NET.Core.Native.IUnknown* punkVal = null, + IDispatch* pdispVal = null, + Silk.NET.Core.Win32Extras.IStream* pStream = null, + IStorage* pStorage = null, + VersionedStream* pVersionedStream = null, + SafeArray* parray = null, + CAC? cac = null, + CAUB? caub = null, + CAI? cai = null, + CAUI? caui = null, + CAL? cal = null, + CAUL? caul = null, + CAH? cah = null, + CAUH? cauh = null, + CAFLT? caflt = null, + CADBL? cadbl = null, + CABool? cabool = null, + CASCode? cascode = null, + CACY? cacy = null, + CADate? cadate = null, + CAFileTime? cafiletime = null, + CACLSID? cauuid = null, + CAClipData? caclipdata = null, + CABSTR? cabstr = null, + CABSTRBlob? cabstrblob = null, + CALPSTR? calpstr = null, + CALPWSTR? calpwstr = null, + CAPropVariant? capropvar = null, + byte* pcVal = null, + byte* pbVal = null, + short* piVal = null, + ushort* puiVal = null, + int* plVal = null, + uint* pulVal = null, + int* pintVal = null, + uint* puintVal = null, + float* pfltVal = null, + double* pdblVal = null, + short* pboolVal = null, + TagDecimal* pdecVal = null, + int* pscode = null, + CY* pcyVal = null, + double* pdate = null, + char** pbstrVal = null, + Silk.NET.Core.Native.IUnknown** ppunkVal = null, + IDispatch** ppdispVal = null, + SafeArray** pparray = null, + PropVariant* pvarVal = null + ) : this() + { + if (vt is not null) + { + Vt = vt.Value; + } + + if (wReserved1 is not null) + { + WReserved1 = wReserved1.Value; + } + + if (wReserved2 is not null) + { + WReserved2 = wReserved2.Value; + } + + if (wReserved3 is not null) + { + WReserved3 = wReserved3.Value; + } + + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (cVal is not null) + { + CVal = cVal.Value; + } + + if (bVal is not null) + { + BVal = bVal.Value; + } + + if (iVal is not null) + { + IVal = iVal.Value; + } + + if (uiVal is not null) + { + UiVal = uiVal.Value; + } + + if (lVal is not null) + { + LVal = lVal.Value; + } + + if (ulVal is not null) + { + UlVal = ulVal.Value; + } + + if (intVal is not null) + { + IntVal = intVal.Value; + } + + if (uintVal is not null) + { + UintVal = uintVal.Value; + } + + if (hVal is not null) + { + HVal = hVal.Value; + } + + if (uhVal is not null) + { + UhVal = uhVal.Value; + } + + if (fltVal is not null) + { + FltVal = fltVal.Value; + } + + if (dblVal is not null) + { + DblVal = dblVal.Value; + } + + if (boolVal is not null) + { + BoolVal = boolVal.Value; + } + + if (oBSOLETEVARIANTBOOL is not null) + { + OBSOLETEVARIANTBOOL = oBSOLETEVARIANTBOOL.Value; + } + + if (scode is not null) + { + Scode = scode.Value; + } + + if (cyVal is not null) + { + CyVal = cyVal.Value; + } + + if (date is not null) + { + Date = date.Value; + } + + if (filetime is not null) + { + Filetime = filetime.Value; + } + + if (puuid is not null) + { + Puuid = puuid; + } + + if (pclipdata is not null) + { + Pclipdata = pclipdata; + } + + if (bstrVal is not null) + { + BstrVal = bstrVal; + } + + if (bstrblobVal is not null) + { + BstrblobVal = bstrblobVal.Value; + } + + if (blob is not null) + { + Blob = blob.Value; + } + + if (pszVal is not null) + { + PszVal = pszVal; + } + + if (pwszVal is not null) + { + PwszVal = pwszVal; + } + + if (punkVal is not null) + { + PunkVal = punkVal; + } + + if (pdispVal is not null) + { + PdispVal = pdispVal; + } + + if (pStream is not null) + { + PStream = pStream; + } + + if (pStorage is not null) + { + PStorage = pStorage; + } + + if (pVersionedStream is not null) + { + PVersionedStream = pVersionedStream; + } + + if (parray is not null) + { + Parray = parray; + } + + if (cac is not null) + { + Cac = cac.Value; + } + + if (caub is not null) + { + Caub = caub.Value; + } + + if (cai is not null) + { + Cai = cai.Value; + } + + if (caui is not null) + { + Caui = caui.Value; + } + + if (cal is not null) + { + Cal = cal.Value; + } + + if (caul is not null) + { + Caul = caul.Value; + } + + if (cah is not null) + { + Cah = cah.Value; + } + + if (cauh is not null) + { + Cauh = cauh.Value; + } + + if (caflt is not null) + { + Caflt = caflt.Value; + } + + if (cadbl is not null) + { + Cadbl = cadbl.Value; + } + + if (cabool is not null) + { + Cabool = cabool.Value; + } + + if (cascode is not null) + { + Cascode = cascode.Value; + } + + if (cacy is not null) + { + Cacy = cacy.Value; + } + + if (cadate is not null) + { + Cadate = cadate.Value; + } + + if (cafiletime is not null) + { + Cafiletime = cafiletime.Value; + } + + if (cauuid is not null) + { + Cauuid = cauuid.Value; + } + + if (caclipdata is not null) + { + Caclipdata = caclipdata.Value; + } + + if (cabstr is not null) + { + Cabstr = cabstr.Value; + } + + if (cabstrblob is not null) + { + Cabstrblob = cabstrblob.Value; + } + + if (calpstr is not null) + { + Calpstr = calpstr.Value; + } + + if (calpwstr is not null) + { + Calpwstr = calpwstr.Value; + } + + if (capropvar is not null) + { + Capropvar = capropvar.Value; + } + + if (pcVal is not null) + { + PcVal = pcVal; + } + + if (pbVal is not null) + { + PbVal = pbVal; + } + + if (piVal is not null) + { + PiVal = piVal; + } + + if (puiVal is not null) + { + PuiVal = puiVal; + } + + if (plVal is not null) + { + PlVal = plVal; + } + + if (pulVal is not null) + { + PulVal = pulVal; + } + + if (pintVal is not null) + { + PintVal = pintVal; + } + + if (puintVal is not null) + { + PuintVal = puintVal; + } + + if (pfltVal is not null) + { + PfltVal = pfltVal; + } + + if (pdblVal is not null) + { + PdblVal = pdblVal; + } + + if (pboolVal is not null) + { + PboolVal = pboolVal; + } + + if (pdecVal is not null) + { + PdecVal = pdecVal; + } + + if (pscode is not null) + { + Pscode = pscode; + } + + if (pcyVal is not null) + { + PcyVal = pcyVal; + } + + if (pdate is not null) + { + Pdate = pdate; + } + + if (pbstrVal is not null) + { + PbstrVal = pbstrVal; + } + + if (ppunkVal is not null) + { + PpunkVal = ppunkVal; + } + + if (ppdispVal is not null) + { + PpdispVal = ppdispVal; + } + + if (pparray is not null) + { + Pparray = pparray; + } + + if (pvarVal is not null) + { + PvarVal = pvarVal; + } + } + + + [NativeName("Type", "VARTYPE")] + [NativeName("Type.Name", "VARTYPE")] + [NativeName("Name", "vt")] + public ushort Vt; + + [NativeName("Type", "PROPVAR_PAD1")] + [NativeName("Type.Name", "PROPVAR_PAD1")] + [NativeName("Name", "wReserved1")] + public ushort WReserved1; + + [NativeName("Type", "PROPVAR_PAD2")] + [NativeName("Type.Name", "PROPVAR_PAD2")] + [NativeName("Name", "wReserved2")] + public ushort WReserved2; + + [NativeName("Type", "PROPVAR_PAD3")] + [NativeName("Type.Name", "PROPVAR_PAD3")] + [NativeName("Name", "wReserved3")] + public ushort WReserved3; + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_propidlbase_L311_C43")] + [NativeName("Name", "anonymous1")] + public PropVariantUnionUnionUnion Anonymous; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte CVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CVal; + } +#else + public byte CVal + { + get => Anonymous.CVal; + set => Anonymous.CVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte BVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BVal; + } +#else + public byte BVal + { + get => Anonymous.BVal; + set => Anonymous.BVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short IVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IVal; + } +#else + public short IVal + { + get => Anonymous.IVal; + set => Anonymous.IVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort UiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UiVal; + } +#else + public ushort UiVal + { + get => Anonymous.UiVal; + set => Anonymous.UiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int LVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].LVal; + } +#else + public int LVal + { + get => Anonymous.LVal; + set => Anonymous.LVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UlVal; + } +#else + public uint UlVal + { + get => Anonymous.UlVal; + set => Anonymous.UlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int IntVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].IntVal; + } +#else + public int IntVal + { + get => Anonymous.IntVal; + set => Anonymous.IntVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint UintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UintVal; + } +#else + public uint UintVal + { + get => Anonymous.UintVal; + set => Anonymous.UintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref long HVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HVal; + } +#else + public long HVal + { + get => Anonymous.HVal; + set => Anonymous.HVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ulong UhVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].UhVal; + } +#else + public ulong UhVal + { + get => Anonymous.UhVal; + set => Anonymous.UhVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float FltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].FltVal; + } +#else + public float FltVal + { + get => Anonymous.FltVal; + set => Anonymous.FltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double DblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].DblVal; + } +#else + public double DblVal + { + get => Anonymous.DblVal; + set => Anonymous.DblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short BoolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BoolVal; + } +#else + public short BoolVal + { + get => Anonymous.BoolVal; + set => Anonymous.BoolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short OBSOLETEVARIANTBOOL + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].OBSOLETEVARIANTBOOL; + } +#else + public short OBSOLETEVARIANTBOOL + { + get => Anonymous.OBSOLETEVARIANTBOOL; + set => Anonymous.OBSOLETEVARIANTBOOL = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int Scode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Scode; + } +#else + public int Scode + { + get => Anonymous.Scode; + set => Anonymous.Scode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY CyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].CyVal; + } +#else + public CY CyVal + { + get => Anonymous.CyVal; + set => Anonymous.CyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double Date + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Date; + } +#else + public double Date + { + get => Anonymous.Date; + set => Anonymous.Date = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.Filetime Filetime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Filetime; + } +#else + public Silk.NET.Core.Win32Extras.Filetime Filetime + { + get => Anonymous.Filetime; + set => Anonymous.Filetime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Guid* Puuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Puuid; + } +#else + public Guid* Puuid + { + get => Anonymous.Puuid; + set => Anonymous.Puuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ClipData* Pclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pclipdata; + } +#else + public ClipData* Pclipdata + { + get => Anonymous.Pclipdata; + set => Anonymous.Pclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* BstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrVal; + } +#else + public char* BstrVal + { + get => Anonymous.BstrVal; + set => Anonymous.BstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref BSTRBlob BstrblobVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].BstrblobVal; + } +#else + public BSTRBlob BstrblobVal + { + get => Anonymous.BstrblobVal; + set => Anonymous.BstrblobVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Blob Blob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Blob; + } +#else + public Blob Blob + { + get => Anonymous.Blob; + set => Anonymous.Blob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PszVal; + } +#else + public byte* PszVal + { + get => Anonymous.PszVal; + set => Anonymous.PszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* PwszVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PwszVal; + } +#else + public char* PwszVal + { + get => Anonymous.PwszVal; + set => Anonymous.PwszVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown* PunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown* PunkVal + { + get => Anonymous.PunkVal; + set => Anonymous.PunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch* PdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdispVal; + } +#else + public IDispatch* PdispVal + { + get => Anonymous.PdispVal; + set => Anonymous.PdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.IStream* PStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStream; + } +#else + public Silk.NET.Core.Win32Extras.IStream* PStream + { + get => Anonymous.PStream; + set => Anonymous.PStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IStorage* PStorage + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PStorage; + } +#else + public IStorage* PStorage + { + get => Anonymous.PStorage; + set => Anonymous.PStorage = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref VersionedStream* PVersionedStream + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PVersionedStream; + } +#else + public VersionedStream* PVersionedStream + { + get => Anonymous.PVersionedStream; + set => Anonymous.PVersionedStream = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray* Parray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Parray; + } +#else + public SafeArray* Parray + { + get => Anonymous.Parray; + set => Anonymous.Parray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAC Cac + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cac; + } +#else + public CAC Cac + { + get => Anonymous.Cac; + set => Anonymous.Cac = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUB Caub + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caub; + } +#else + public CAUB Caub + { + get => Anonymous.Caub; + set => Anonymous.Caub = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAI Cai + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cai; + } +#else + public CAI Cai + { + get => Anonymous.Cai; + set => Anonymous.Cai = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUI Caui + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caui; + } +#else + public CAUI Caui + { + get => Anonymous.Caui; + set => Anonymous.Caui = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAL Cal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cal; + } +#else + public CAL Cal + { + get => Anonymous.Cal; + set => Anonymous.Cal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUL Caul + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caul; + } +#else + public CAUL Caul + { + get => Anonymous.Caul; + set => Anonymous.Caul = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAH Cah + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cah; + } +#else + public CAH Cah + { + get => Anonymous.Cah; + set => Anonymous.Cah = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAUH Cauh + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauh; + } +#else + public CAUH Cauh + { + get => Anonymous.Cauh; + set => Anonymous.Cauh = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFLT Caflt + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caflt; + } +#else + public CAFLT Caflt + { + get => Anonymous.Caflt; + set => Anonymous.Caflt = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADBL Cadbl + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadbl; + } +#else + public CADBL Cadbl + { + get => Anonymous.Cadbl; + set => Anonymous.Cadbl = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABool Cabool + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabool; + } +#else + public CABool Cabool + { + get => Anonymous.Cabool; + set => Anonymous.Cabool = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CASCode Cascode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cascode; + } +#else + public CASCode Cascode + { + get => Anonymous.Cascode; + set => Anonymous.Cascode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACY Cacy + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cacy; + } +#else + public CACY Cacy + { + get => Anonymous.Cacy; + set => Anonymous.Cacy = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CADate Cadate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cadate; + } +#else + public CADate Cadate + { + get => Anonymous.Cadate; + set => Anonymous.Cadate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAFileTime Cafiletime + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cafiletime; + } +#else + public CAFileTime Cafiletime + { + get => Anonymous.Cafiletime; + set => Anonymous.Cafiletime = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CACLSID Cauuid + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cauuid; + } +#else + public CACLSID Cauuid + { + get => Anonymous.Cauuid; + set => Anonymous.Cauuid = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAClipData Caclipdata + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Caclipdata; + } +#else + public CAClipData Caclipdata + { + get => Anonymous.Caclipdata; + set => Anonymous.Caclipdata = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTR Cabstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstr; + } +#else + public CABSTR Cabstr + { + get => Anonymous.Cabstr; + set => Anonymous.Cabstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CABSTRBlob Cabstrblob + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Cabstrblob; + } +#else + public CABSTRBlob Cabstrblob + { + get => Anonymous.Cabstrblob; + set => Anonymous.Cabstrblob = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPSTR Calpstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpstr; + } +#else + public CALPSTR Calpstr + { + get => Anonymous.Calpstr; + set => Anonymous.Calpstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CALPWSTR Calpwstr + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Calpwstr; + } +#else + public CALPWSTR Calpwstr + { + get => Anonymous.Calpwstr; + set => Anonymous.Calpwstr = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CAPropVariant Capropvar + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Capropvar; + } +#else + public CAPropVariant Capropvar + { + get => Anonymous.Capropvar; + set => Anonymous.Capropvar = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PcVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcVal; + } +#else + public byte* PcVal + { + get => Anonymous.PcVal; + set => Anonymous.PcVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref byte* PbVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbVal; + } +#else + public byte* PbVal + { + get => Anonymous.PbVal; + set => Anonymous.PbVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PiVal; + } +#else + public short* PiVal + { + get => Anonymous.PiVal; + set => Anonymous.PiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ushort* PuiVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuiVal; + } +#else + public ushort* PuiVal + { + get => Anonymous.PuiVal; + set => Anonymous.PuiVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PlVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PlVal; + } +#else + public int* PlVal + { + get => Anonymous.PlVal; + set => Anonymous.PlVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PulVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PulVal; + } +#else + public uint* PulVal + { + get => Anonymous.PulVal; + set => Anonymous.PulVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* PintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PintVal; + } +#else + public int* PintVal + { + get => Anonymous.PintVal; + set => Anonymous.PintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint* PuintVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PuintVal; + } +#else + public uint* PuintVal + { + get => Anonymous.PuintVal; + set => Anonymous.PuintVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref float* PfltVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PfltVal; + } +#else + public float* PfltVal + { + get => Anonymous.PfltVal; + set => Anonymous.PfltVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* PdblVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdblVal; + } +#else + public double* PdblVal + { + get => Anonymous.PdblVal; + set => Anonymous.PdblVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref short* PboolVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PboolVal; + } +#else + public short* PboolVal + { + get => Anonymous.PboolVal; + set => Anonymous.PboolVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref TagDecimal* PdecVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PdecVal; + } +#else + public TagDecimal* PdecVal + { + get => Anonymous.PdecVal; + set => Anonymous.PdecVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref int* Pscode + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pscode; + } +#else + public int* Pscode + { + get => Anonymous.Pscode; + set => Anonymous.Pscode = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref CY* PcyVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PcyVal; + } +#else + public CY* PcyVal + { + get => Anonymous.PcyVal; + set => Anonymous.PcyVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref double* Pdate + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pdate; + } +#else + public double* Pdate + { + get => Anonymous.Pdate; + set => Anonymous.Pdate = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char** PbstrVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PbstrVal; + } +#else + public char** PbstrVal + { + get => Anonymous.PbstrVal; + set => Anonymous.PbstrVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Native.IUnknown** PpunkVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpunkVal; + } +#else + public Silk.NET.Core.Native.IUnknown** PpunkVal + { + get => Anonymous.PpunkVal; + set => Anonymous.PpunkVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IDispatch** PpdispVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PpdispVal; + } +#else + public IDispatch** PpdispVal + { + get => Anonymous.PpdispVal; + set => Anonymous.PpdispVal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref SafeArray** Pparray + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pparray; + } +#else + public SafeArray** Pparray + { + get => Anonymous.Pparray; + set => Anonymous.Pparray = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref PropVariant* PvarVal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].PvarVal; + } +#else + public PropVariant* PvarVal + { + get => Anonymous.PvarVal; + set => Anonymous.PvarVal = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnionUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnionUnion.gen.cs new file mode 100644 index 0000000000..73ff1007da --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropVariantUnionUnionUnion.gen.cs @@ -0,0 +1,905 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] + [NativeName("Name", "__AnonymousRecord_propidlbase_L311_C43")] + public unsafe partial struct PropVariantUnionUnionUnion + { + public PropVariantUnionUnionUnion + ( + byte? cVal = null, + byte? bVal = null, + short? iVal = null, + ushort? uiVal = null, + int? lVal = null, + uint? ulVal = null, + int? intVal = null, + uint? uintVal = null, + long? hVal = null, + ulong? uhVal = null, + float? fltVal = null, + double? dblVal = null, + short? boolVal = null, + short? oBSOLETEVARIANTBOOL = null, + int? scode = null, + CY? cyVal = null, + double? date = null, + Silk.NET.Core.Win32Extras.Filetime? filetime = null, + Guid* puuid = null, + ClipData* pclipdata = null, + char* bstrVal = null, + BSTRBlob? bstrblobVal = null, + Blob? blob = null, + byte* pszVal = null, + char* pwszVal = null, + Silk.NET.Core.Native.IUnknown* punkVal = null, + IDispatch* pdispVal = null, + Silk.NET.Core.Win32Extras.IStream* pStream = null, + IStorage* pStorage = null, + VersionedStream* pVersionedStream = null, + SafeArray* parray = null, + CAC? cac = null, + CAUB? caub = null, + CAI? cai = null, + CAUI? caui = null, + CAL? cal = null, + CAUL? caul = null, + CAH? cah = null, + CAUH? cauh = null, + CAFLT? caflt = null, + CADBL? cadbl = null, + CABool? cabool = null, + CASCode? cascode = null, + CACY? cacy = null, + CADate? cadate = null, + CAFileTime? cafiletime = null, + CACLSID? cauuid = null, + CAClipData? caclipdata = null, + CABSTR? cabstr = null, + CABSTRBlob? cabstrblob = null, + CALPSTR? calpstr = null, + CALPWSTR? calpwstr = null, + CAPropVariant? capropvar = null, + byte* pcVal = null, + byte* pbVal = null, + short* piVal = null, + ushort* puiVal = null, + int* plVal = null, + uint* pulVal = null, + int* pintVal = null, + uint* puintVal = null, + float* pfltVal = null, + double* pdblVal = null, + short* pboolVal = null, + TagDecimal* pdecVal = null, + int* pscode = null, + CY* pcyVal = null, + double* pdate = null, + char** pbstrVal = null, + Silk.NET.Core.Native.IUnknown** ppunkVal = null, + IDispatch** ppdispVal = null, + SafeArray** pparray = null, + PropVariant* pvarVal = null + ) : this() + { + if (cVal is not null) + { + CVal = cVal.Value; + } + + if (bVal is not null) + { + BVal = bVal.Value; + } + + if (iVal is not null) + { + IVal = iVal.Value; + } + + if (uiVal is not null) + { + UiVal = uiVal.Value; + } + + if (lVal is not null) + { + LVal = lVal.Value; + } + + if (ulVal is not null) + { + UlVal = ulVal.Value; + } + + if (intVal is not null) + { + IntVal = intVal.Value; + } + + if (uintVal is not null) + { + UintVal = uintVal.Value; + } + + if (hVal is not null) + { + HVal = hVal.Value; + } + + if (uhVal is not null) + { + UhVal = uhVal.Value; + } + + if (fltVal is not null) + { + FltVal = fltVal.Value; + } + + if (dblVal is not null) + { + DblVal = dblVal.Value; + } + + if (boolVal is not null) + { + BoolVal = boolVal.Value; + } + + if (oBSOLETEVARIANTBOOL is not null) + { + OBSOLETEVARIANTBOOL = oBSOLETEVARIANTBOOL.Value; + } + + if (scode is not null) + { + Scode = scode.Value; + } + + if (cyVal is not null) + { + CyVal = cyVal.Value; + } + + if (date is not null) + { + Date = date.Value; + } + + if (filetime is not null) + { + Filetime = filetime.Value; + } + + if (puuid is not null) + { + Puuid = puuid; + } + + if (pclipdata is not null) + { + Pclipdata = pclipdata; + } + + if (bstrVal is not null) + { + BstrVal = bstrVal; + } + + if (bstrblobVal is not null) + { + BstrblobVal = bstrblobVal.Value; + } + + if (blob is not null) + { + Blob = blob.Value; + } + + if (pszVal is not null) + { + PszVal = pszVal; + } + + if (pwszVal is not null) + { + PwszVal = pwszVal; + } + + if (punkVal is not null) + { + PunkVal = punkVal; + } + + if (pdispVal is not null) + { + PdispVal = pdispVal; + } + + if (pStream is not null) + { + PStream = pStream; + } + + if (pStorage is not null) + { + PStorage = pStorage; + } + + if (pVersionedStream is not null) + { + PVersionedStream = pVersionedStream; + } + + if (parray is not null) + { + Parray = parray; + } + + if (cac is not null) + { + Cac = cac.Value; + } + + if (caub is not null) + { + Caub = caub.Value; + } + + if (cai is not null) + { + Cai = cai.Value; + } + + if (caui is not null) + { + Caui = caui.Value; + } + + if (cal is not null) + { + Cal = cal.Value; + } + + if (caul is not null) + { + Caul = caul.Value; + } + + if (cah is not null) + { + Cah = cah.Value; + } + + if (cauh is not null) + { + Cauh = cauh.Value; + } + + if (caflt is not null) + { + Caflt = caflt.Value; + } + + if (cadbl is not null) + { + Cadbl = cadbl.Value; + } + + if (cabool is not null) + { + Cabool = cabool.Value; + } + + if (cascode is not null) + { + Cascode = cascode.Value; + } + + if (cacy is not null) + { + Cacy = cacy.Value; + } + + if (cadate is not null) + { + Cadate = cadate.Value; + } + + if (cafiletime is not null) + { + Cafiletime = cafiletime.Value; + } + + if (cauuid is not null) + { + Cauuid = cauuid.Value; + } + + if (caclipdata is not null) + { + Caclipdata = caclipdata.Value; + } + + if (cabstr is not null) + { + Cabstr = cabstr.Value; + } + + if (cabstrblob is not null) + { + Cabstrblob = cabstrblob.Value; + } + + if (calpstr is not null) + { + Calpstr = calpstr.Value; + } + + if (calpwstr is not null) + { + Calpwstr = calpwstr.Value; + } + + if (capropvar is not null) + { + Capropvar = capropvar.Value; + } + + if (pcVal is not null) + { + PcVal = pcVal; + } + + if (pbVal is not null) + { + PbVal = pbVal; + } + + if (piVal is not null) + { + PiVal = piVal; + } + + if (puiVal is not null) + { + PuiVal = puiVal; + } + + if (plVal is not null) + { + PlVal = plVal; + } + + if (pulVal is not null) + { + PulVal = pulVal; + } + + if (pintVal is not null) + { + PintVal = pintVal; + } + + if (puintVal is not null) + { + PuintVal = puintVal; + } + + if (pfltVal is not null) + { + PfltVal = pfltVal; + } + + if (pdblVal is not null) + { + PdblVal = pdblVal; + } + + if (pboolVal is not null) + { + PboolVal = pboolVal; + } + + if (pdecVal is not null) + { + PdecVal = pdecVal; + } + + if (pscode is not null) + { + Pscode = pscode; + } + + if (pcyVal is not null) + { + PcyVal = pcyVal; + } + + if (pdate is not null) + { + Pdate = pdate; + } + + if (pbstrVal is not null) + { + PbstrVal = pbstrVal; + } + + if (ppunkVal is not null) + { + PpunkVal = ppunkVal; + } + + if (ppdispVal is not null) + { + PpdispVal = ppdispVal; + } + + if (pparray is not null) + { + Pparray = pparray; + } + + if (pvarVal is not null) + { + PvarVal = pvarVal; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "CHAR")] + [NativeName("Type.Name", "CHAR")] + [NativeName("Name", "cVal")] + public byte CVal; + + [FieldOffset(0)] + [NativeName("Type", "UCHAR")] + [NativeName("Type.Name", "UCHAR")] + [NativeName("Name", "bVal")] + public byte BVal; + + [FieldOffset(0)] + [NativeName("Type", "SHORT")] + [NativeName("Type.Name", "SHORT")] + [NativeName("Name", "iVal")] + public short IVal; + + [FieldOffset(0)] + [NativeName("Type", "USHORT")] + [NativeName("Type.Name", "USHORT")] + [NativeName("Name", "uiVal")] + public ushort UiVal; + + [FieldOffset(0)] + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "lVal")] + public int LVal; + + [FieldOffset(0)] + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "ulVal")] + public uint UlVal; + + [FieldOffset(0)] + [NativeName("Type", "INT")] + [NativeName("Type.Name", "INT")] + [NativeName("Name", "intVal")] + public int IntVal; + + [FieldOffset(0)] + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "uintVal")] + public uint UintVal; + + [FieldOffset(0)] + [NativeName("Type", "LARGE_INTEGER")] + [NativeName("Type.Name", "LARGE_INTEGER")] + [NativeName("Name", "hVal")] + public long HVal; + + [FieldOffset(0)] + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "uhVal")] + public ulong UhVal; + + [FieldOffset(0)] + [NativeName("Type", "FLOAT")] + [NativeName("Type.Name", "FLOAT")] + [NativeName("Name", "fltVal")] + public float FltVal; + + [FieldOffset(0)] + [NativeName("Type", "DOUBLE")] + [NativeName("Type.Name", "DOUBLE")] + [NativeName("Name", "dblVal")] + public double DblVal; + + [FieldOffset(0)] + [NativeName("Type", "VARIANT_BOOL")] + [NativeName("Type.Name", "VARIANT_BOOL")] + [NativeName("Name", "boolVal")] + public short BoolVal; + + [FieldOffset(0)] + [NativeName("Type", "VARIANT_BOOL")] + [NativeName("Type.Name", "VARIANT_BOOL")] + [NativeName("Name", "__OBSOLETE__VARIANT_BOOL")] + public short OBSOLETEVARIANTBOOL; + + [FieldOffset(0)] + [NativeName("Type", "SCODE")] + [NativeName("Type.Name", "SCODE")] + [NativeName("Name", "scode")] + public int Scode; + + [FieldOffset(0)] + [NativeName("Type", "CY")] + [NativeName("Type.Name", "CY")] + [NativeName("Name", "cyVal")] + public CY CyVal; + + [FieldOffset(0)] + [NativeName("Type", "DATE")] + [NativeName("Type.Name", "DATE")] + [NativeName("Name", "date")] + public double Date; + + [FieldOffset(0)] + [NativeName("Type", "FILETIME")] + [NativeName("Type.Name", "FILETIME")] + [NativeName("Name", "filetime")] + public Silk.NET.Core.Win32Extras.Filetime Filetime; + + [FieldOffset(0)] + [NativeName("Type", "CLSID *")] + [NativeName("Type.Name", "CLSID *")] + [NativeName("Name", "puuid")] + public Guid* Puuid; + + [FieldOffset(0)] + [NativeName("Type", "CLIPDATA *")] + [NativeName("Type.Name", "CLIPDATA *")] + [NativeName("Name", "pclipdata")] + public ClipData* Pclipdata; + + [FieldOffset(0)] + [NativeName("Type", "BSTR")] + [NativeName("Type.Name", "BSTR")] + [NativeName("Name", "bstrVal")] + public char* BstrVal; + + [FieldOffset(0)] + [NativeName("Type", "BSTRBLOB")] + [NativeName("Type.Name", "BSTRBLOB")] + [NativeName("Name", "bstrblobVal")] + public BSTRBlob BstrblobVal; + + [FieldOffset(0)] + [NativeName("Type", "BLOB")] + [NativeName("Type.Name", "BLOB")] + [NativeName("Name", "blob")] + public Blob Blob; + + [FieldOffset(0)] + [NativeName("Type", "LPSTR")] + [NativeName("Type.Name", "LPSTR")] + [NativeName("Name", "pszVal")] + public byte* PszVal; + + [FieldOffset(0)] + [NativeName("Type", "LPWSTR")] + [NativeName("Type.Name", "LPWSTR")] + [NativeName("Name", "pwszVal")] + public char* PwszVal; + + [FieldOffset(0)] + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "punkVal")] + public Silk.NET.Core.Native.IUnknown* PunkVal; + + [FieldOffset(0)] + [NativeName("Type", "IDispatch *")] + [NativeName("Type.Name", "IDispatch *")] + [NativeName("Name", "pdispVal")] + public IDispatch* PdispVal; + + [FieldOffset(0)] + [NativeName("Type", "IStream *")] + [NativeName("Type.Name", "IStream *")] + [NativeName("Name", "pStream")] + public Silk.NET.Core.Win32Extras.IStream* PStream; + + [FieldOffset(0)] + [NativeName("Type", "IStorage *")] + [NativeName("Type.Name", "IStorage *")] + [NativeName("Name", "pStorage")] + public IStorage* PStorage; + + [FieldOffset(0)] + [NativeName("Type", "LPVERSIONEDSTREAM")] + [NativeName("Type.Name", "LPVERSIONEDSTREAM")] + [NativeName("Name", "pVersionedStream")] + public VersionedStream* PVersionedStream; + + [FieldOffset(0)] + [NativeName("Type", "LPSAFEARRAY")] + [NativeName("Type.Name", "LPSAFEARRAY")] + [NativeName("Name", "parray")] + public SafeArray* Parray; + + [FieldOffset(0)] + [NativeName("Type", "CAC")] + [NativeName("Type.Name", "CAC")] + [NativeName("Name", "cac")] + public CAC Cac; + + [FieldOffset(0)] + [NativeName("Type", "CAUB")] + [NativeName("Type.Name", "CAUB")] + [NativeName("Name", "caub")] + public CAUB Caub; + + [FieldOffset(0)] + [NativeName("Type", "CAI")] + [NativeName("Type.Name", "CAI")] + [NativeName("Name", "cai")] + public CAI Cai; + + [FieldOffset(0)] + [NativeName("Type", "CAUI")] + [NativeName("Type.Name", "CAUI")] + [NativeName("Name", "caui")] + public CAUI Caui; + + [FieldOffset(0)] + [NativeName("Type", "CAL")] + [NativeName("Type.Name", "CAL")] + [NativeName("Name", "cal")] + public CAL Cal; + + [FieldOffset(0)] + [NativeName("Type", "CAUL")] + [NativeName("Type.Name", "CAUL")] + [NativeName("Name", "caul")] + public CAUL Caul; + + [FieldOffset(0)] + [NativeName("Type", "CAH")] + [NativeName("Type.Name", "CAH")] + [NativeName("Name", "cah")] + public CAH Cah; + + [FieldOffset(0)] + [NativeName("Type", "CAUH")] + [NativeName("Type.Name", "CAUH")] + [NativeName("Name", "cauh")] + public CAUH Cauh; + + [FieldOffset(0)] + [NativeName("Type", "CAFLT")] + [NativeName("Type.Name", "CAFLT")] + [NativeName("Name", "caflt")] + public CAFLT Caflt; + + [FieldOffset(0)] + [NativeName("Type", "CADBL")] + [NativeName("Type.Name", "CADBL")] + [NativeName("Name", "cadbl")] + public CADBL Cadbl; + + [FieldOffset(0)] + [NativeName("Type", "CABOOL")] + [NativeName("Type.Name", "CABOOL")] + [NativeName("Name", "cabool")] + public CABool Cabool; + + [FieldOffset(0)] + [NativeName("Type", "CASCODE")] + [NativeName("Type.Name", "CASCODE")] + [NativeName("Name", "cascode")] + public CASCode Cascode; + + [FieldOffset(0)] + [NativeName("Type", "CACY")] + [NativeName("Type.Name", "CACY")] + [NativeName("Name", "cacy")] + public CACY Cacy; + + [FieldOffset(0)] + [NativeName("Type", "CADATE")] + [NativeName("Type.Name", "CADATE")] + [NativeName("Name", "cadate")] + public CADate Cadate; + + [FieldOffset(0)] + [NativeName("Type", "CAFILETIME")] + [NativeName("Type.Name", "CAFILETIME")] + [NativeName("Name", "cafiletime")] + public CAFileTime Cafiletime; + + [FieldOffset(0)] + [NativeName("Type", "CACLSID")] + [NativeName("Type.Name", "CACLSID")] + [NativeName("Name", "cauuid")] + public CACLSID Cauuid; + + [FieldOffset(0)] + [NativeName("Type", "CACLIPDATA")] + [NativeName("Type.Name", "CACLIPDATA")] + [NativeName("Name", "caclipdata")] + public CAClipData Caclipdata; + + [FieldOffset(0)] + [NativeName("Type", "CABSTR")] + [NativeName("Type.Name", "CABSTR")] + [NativeName("Name", "cabstr")] + public CABSTR Cabstr; + + [FieldOffset(0)] + [NativeName("Type", "CABSTRBLOB")] + [NativeName("Type.Name", "CABSTRBLOB")] + [NativeName("Name", "cabstrblob")] + public CABSTRBlob Cabstrblob; + + [FieldOffset(0)] + [NativeName("Type", "CALPSTR")] + [NativeName("Type.Name", "CALPSTR")] + [NativeName("Name", "calpstr")] + public CALPSTR Calpstr; + + [FieldOffset(0)] + [NativeName("Type", "CALPWSTR")] + [NativeName("Type.Name", "CALPWSTR")] + [NativeName("Name", "calpwstr")] + public CALPWSTR Calpwstr; + + [FieldOffset(0)] + [NativeName("Type", "CAPROPVARIANT")] + [NativeName("Type.Name", "CAPROPVARIANT")] + [NativeName("Name", "capropvar")] + public CAPropVariant Capropvar; + + [FieldOffset(0)] + [NativeName("Type", "CHAR *")] + [NativeName("Type.Name", "CHAR *")] + [NativeName("Name", "pcVal")] + public byte* PcVal; + + [FieldOffset(0)] + [NativeName("Type", "UCHAR *")] + [NativeName("Type.Name", "UCHAR *")] + [NativeName("Name", "pbVal")] + public byte* PbVal; + + [FieldOffset(0)] + [NativeName("Type", "SHORT *")] + [NativeName("Type.Name", "SHORT *")] + [NativeName("Name", "piVal")] + public short* PiVal; + + [FieldOffset(0)] + [NativeName("Type", "USHORT *")] + [NativeName("Type.Name", "USHORT *")] + [NativeName("Name", "puiVal")] + public ushort* PuiVal; + + [FieldOffset(0)] + [NativeName("Type", "LONG *")] + [NativeName("Type.Name", "LONG *")] + [NativeName("Name", "plVal")] + public int* PlVal; + + [FieldOffset(0)] + [NativeName("Type", "ULONG *")] + [NativeName("Type.Name", "ULONG *")] + [NativeName("Name", "pulVal")] + public uint* PulVal; + + [FieldOffset(0)] + [NativeName("Type", "INT *")] + [NativeName("Type.Name", "INT *")] + [NativeName("Name", "pintVal")] + public int* PintVal; + + [FieldOffset(0)] + [NativeName("Type", "UINT *")] + [NativeName("Type.Name", "UINT *")] + [NativeName("Name", "puintVal")] + public uint* PuintVal; + + [FieldOffset(0)] + [NativeName("Type", "FLOAT *")] + [NativeName("Type.Name", "FLOAT *")] + [NativeName("Name", "pfltVal")] + public float* PfltVal; + + [FieldOffset(0)] + [NativeName("Type", "DOUBLE *")] + [NativeName("Type.Name", "DOUBLE *")] + [NativeName("Name", "pdblVal")] + public double* PdblVal; + + [FieldOffset(0)] + [NativeName("Type", "VARIANT_BOOL *")] + [NativeName("Type.Name", "VARIANT_BOOL *")] + [NativeName("Name", "pboolVal")] + public short* PboolVal; + + [FieldOffset(0)] + [NativeName("Type", "DECIMAL *")] + [NativeName("Type.Name", "DECIMAL *")] + [NativeName("Name", "pdecVal")] + public TagDecimal* PdecVal; + + [FieldOffset(0)] + [NativeName("Type", "SCODE *")] + [NativeName("Type.Name", "SCODE *")] + [NativeName("Name", "pscode")] + public int* Pscode; + + [FieldOffset(0)] + [NativeName("Type", "CY *")] + [NativeName("Type.Name", "CY *")] + [NativeName("Name", "pcyVal")] + public CY* PcyVal; + + [FieldOffset(0)] + [NativeName("Type", "DATE *")] + [NativeName("Type.Name", "DATE *")] + [NativeName("Name", "pdate")] + public double* Pdate; + + [FieldOffset(0)] + [NativeName("Type", "BSTR *")] + [NativeName("Type.Name", "BSTR *")] + [NativeName("Name", "pbstrVal")] + public char** PbstrVal; + + [FieldOffset(0)] + [NativeName("Type", "IUnknown **")] + [NativeName("Type.Name", "IUnknown **")] + [NativeName("Name", "ppunkVal")] + public Silk.NET.Core.Native.IUnknown** PpunkVal; + + [FieldOffset(0)] + [NativeName("Type", "IDispatch **")] + [NativeName("Type.Name", "IDispatch **")] + [NativeName("Name", "ppdispVal")] + public IDispatch** PpdispVal; + + [FieldOffset(0)] + [NativeName("Type", "LPSAFEARRAY *")] + [NativeName("Type.Name", "LPSAFEARRAY *")] + [NativeName("Name", "pparray")] + public SafeArray** Pparray; + + [FieldOffset(0)] + [NativeName("Type", "PROPVARIANT *")] + [NativeName("Type.Name", "PROPVARIANT *")] + [NativeName("Name", "pvarVal")] + public PropVariant* PvarVal; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBag2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBag2VtblExtensions.gen.cs new file mode 100644 index 0000000000..e4aad2d9f4 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBag2VtblExtensions.gen.cs @@ -0,0 +1,1034 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PropertyBag2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValue, phrError); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValue, phrErrorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValuePtr, phrError); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLog, pvarValuePtr, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValue, phrError); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValue, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValuePtr, phrError); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBag, pErrLogPtr, pvarValuePtr, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValue, phrError); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValue, phrErrorPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValuePtr, phrError); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, IErrorLog* pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLog, pvarValuePtr, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValue, phrError); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, Variant* pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValue, phrErrorPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValuePtr, phrError); + } + } + } + return ret; + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ref IErrorLog pErrLog, ref Variant pvarValue, ref int phrError) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + fixed (int* phrErrorPtr = &phrError) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cProperties, pPropBagPtr, pErrLogPtr, pvarValuePtr, phrErrorPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Variant* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBag, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ref Variant pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBag, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, Variant* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBagPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ref Variant pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (Variant* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cProperties, pPropBagPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CountProperties(this ComPtr thisVtbl, uint* pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcProperties); + return ret; + } + + /// To be documented. + public static int CountProperties(this ComPtr thisVtbl, ref uint pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcPropertiesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, PropBag2* pPropBag, uint* pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBag, pcProperties); + return ret; + } + + /// To be documented. + public static unsafe int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, PropBag2* pPropBag, ref uint pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBag, pcPropertiesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, ref PropBag2 pPropBag, uint* pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBagPtr, pcProperties); + } + return ret; + } + + /// To be documented. + public static int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, ref PropBag2 pPropBag, ref uint pcProperties) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropBag2* pPropBagPtr = &pPropBag) + { + fixed (uint* pcPropertiesPtr = &pcProperties) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iProperty, cProperties, pPropBagPtr, pcPropertiesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObject, pErrLog); + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObject, pErrLogPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObjectPtr, pErrLog); + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrName, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLog); + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLogPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLog); + } + } + return ret; + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pstrNamePtr = &pstrName) + { + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLog); + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObject, pErrLogPtr); + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLog); + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ref IErrorLog pErrLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pstrNamePtr = (byte*) SilkMarshal.StringToPtr(pstrName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* pUnkObjectPtr = &pUnkObject) + { + fixed (IErrorLog* pErrLogPtr = &pErrLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pstrNamePtr, dwHint, pUnkObjectPtr, pErrLogPtr); + } + } + SilkMarshal.Free((nint)pstrNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, Variant* pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, pErrLog, pvarValue, ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, Variant* pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, ref phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Span pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, pErrLog, ref pvarValue.GetPinnableReference(), phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, ref Variant pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, IErrorLog* pErrLog, Span pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, pErrLog, ref pvarValue.GetPinnableReference(), ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, ComPtr pErrLog, ref Variant pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, ref phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Span pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, ref pErrLog.GetPinnableReference(), pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Span pErrLog, Variant* pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, ref pErrLog.GetPinnableReference(), pvarValue, ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Span pErrLog, Span pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, ref pErrLog.GetPinnableReference(), ref pvarValue.GetPinnableReference(), phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Span pErrLog, Span pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, pPropBag, ref pErrLog.GetPinnableReference(), ref pvarValue.GetPinnableReference(), ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, IErrorLog* pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), pErrLog, pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, Variant* pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, IErrorLog* pErrLog, Variant* pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), pErrLog, pvarValue, ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, Variant* pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, pvarValue, ref phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, IErrorLog* pErrLog, Span pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), pErrLog, ref pvarValue.GetPinnableReference(), phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, ref Variant pvarValue, int* phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, IErrorLog* pErrLog, Span pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), pErrLog, ref pvarValue.GetPinnableReference(), ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, uint cProperties, ref PropBag2 pPropBag, ComPtr pErrLog, ref Variant pvarValue, ref int phrError) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(cProperties, ref pPropBag, (IErrorLog*) pErrLog.Handle, ref pvarValue, ref phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Span pErrLog, Variant* pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), ref pErrLog.GetPinnableReference(), pvarValue, phrError); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Span pErrLog, Variant* pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), ref pErrLog.GetPinnableReference(), pvarValue, ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Span pErrLog, Span pvarValue, int* phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), ref pErrLog.GetPinnableReference(), ref pvarValue.GetPinnableReference(), phrError); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Span pErrLog, Span pvarValue, Span phrError) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(cProperties, ref pPropBag.GetPinnableReference(), ref pErrLog.GetPinnableReference(), ref pvarValue.GetPinnableReference(), ref phrError.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, uint cProperties, PropBag2* pPropBag, Span pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(cProperties, pPropBag, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Variant* pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(cProperties, ref pPropBag.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, uint cProperties, Span pPropBag, Span pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(cProperties, ref pPropBag.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int CountProperties(this ComPtr thisVtbl, Span pcProperties) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CountProperties(ref pcProperties.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, PropBag2* pPropBag, Span pcProperties) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPropertyInfo(iProperty, cProperties, pPropBag, ref pcProperties.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, Span pPropBag, uint* pcProperties) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPropertyInfo(iProperty, cProperties, ref pPropBag.GetPinnableReference(), pcProperties); + } + + /// To be documented. + public static int GetPropertyInfo(this ComPtr thisVtbl, uint iProperty, uint cProperties, Span pPropBag, Span pcProperties) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPropertyInfo(iProperty, cProperties, ref pPropBag.GetPinnableReference(), ref pcProperties.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, pUnkObject, ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Span pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject.GetPinnableReference(), pErrLog); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pstrName, uint dwHint, Span pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject.GetPinnableReference(), ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(in pstrName.GetPinnableReference(), dwHint, pUnkObject, pErrLog); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(in pstrName.GetPinnableReference(), dwHint, pUnkObject, ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pstrName, uint dwHint, Span pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(in pstrName.GetPinnableReference(), dwHint, ref pUnkObject.GetPinnableReference(), pErrLog); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(in pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pstrName, uint dwHint, Span pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(in pstrName.GetPinnableReference(), dwHint, ref pUnkObject.GetPinnableReference(), ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ComPtr pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Silk.NET.Core.Native.IUnknown* pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, pUnkObject, ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ComPtr pUnkObject, ref IErrorLog pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, (Silk.NET.Core.Native.IUnknown*) pUnkObject.Handle, ref pErrLog); + } + + /// To be documented. + public static unsafe int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Span pUnkObject, IErrorLog* pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject.GetPinnableReference(), pErrLog); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, ref Silk.NET.Core.Native.IUnknown pUnkObject, ComPtr pErrLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject, (IErrorLog*) pErrLog.Handle); + } + + /// To be documented. + public static int LoadObject(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pstrName, uint dwHint, Span pUnkObject, Span pErrLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadObject(pstrName, dwHint, ref pUnkObject.GetPinnableReference(), ref pErrLog.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBagVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBagVtblExtensions.gen.cs new file mode 100644 index 0000000000..3f7a1e19cd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyBagVtblExtensions.gen.cs @@ -0,0 +1,518 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PropertyBagVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVar, pErrorLog); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVar, pErrorLogPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVarPtr, pErrorLog); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropName, pVarPtr, pErrorLogPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLog); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLogPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLog); + } + } + return ret; + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLogPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLog); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVar, pErrorLogPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLog); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + fixed (IErrorLog* pErrorLogPtr = &pErrorLog) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszPropNamePtr, pVarPtr, pErrorLogPtr); + } + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropName, pVar); + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropName, pVarPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVar); + } + return ret; + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszPropNamePtr = &pszPropName) + { + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVarPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVar); + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszPropNamePtr = (byte*) SilkMarshal.StringToPtr(pszPropName, NativeStringEncoding.UTF8); + fixed (Variant* pVarPtr = &pVar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pszPropNamePtr, pVarPtr); + } + SilkMarshal.Free((nint)pszPropNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(in pszPropName.GetPinnableReference(), pVar, pErrorLog); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Read(pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(pszPropName, ref pVar.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(in pszPropName.GetPinnableReference(), pVar); + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference()); + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(pszPropName, ref pVar.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyNotifySinkVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyNotifySinkVtblExtensions.gen.cs new file mode 100644 index 0000000000..55ea3698a7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyNotifySinkVtblExtensions.gen.cs @@ -0,0 +1,139 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PropertyNotifySinkVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int OnChanged(this ComPtr thisVtbl, int dispID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dispID); + return ret; + } + + /// To be documented. + public static int OnRequestEdit(this ComPtr thisVtbl, int dispID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dispID); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertySetStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertySetStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..0daf900603 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertySetStorageVtblExtensions.gen.cs @@ -0,0 +1,447 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PropertySetStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsid, grfFlags, grfMode, ppprstg); + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsid, grfFlags, grfMode, ppprstgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsidPtr, grfFlags, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtid, pclsidPtr, grfFlags, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsid, grfFlags, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsid, grfFlags, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsidPtr, grfFlags, grfMode, ppprstg); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (Guid* pclsidPtr = &pclsid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rfmtidPtr, pclsidPtr, grfFlags, grfMode, ppprstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, Guid* rfmtid, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtid, grfMode, ppprstg); + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, Guid* rfmtid, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtid, grfMode, ppprstgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, ref Guid rfmtid, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtidPtr, grfMode, ppprstg); + } + return ret; + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, ref Guid rfmtid, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + fixed (IPropertyStorage** ppprstgPtr = &ppprstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rfmtidPtr, grfMode, ppprstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Delete(this ComPtr thisVtbl, Guid* rfmtid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rfmtid); + return ret; + } + + /// To be documented. + public static int Delete(this ComPtr thisVtbl, ref Guid rfmtid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rfmtidPtr = &rfmtid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rfmtidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, IEnumSTATPROPSETSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, ref IEnumSTATPROPSETSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATPROPSETSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Create(rfmtid, pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(rfmtid, in pclsid.GetPinnableReference(), grfFlags, grfMode, ppprstg); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Create(rfmtid, in pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Guid* rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(rfmtid, in pclsid.GetPinnableReference(), grfFlags, grfMode, ref ppprstg); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Span rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(ref rfmtid.GetPinnableReference(), pclsid, grfFlags, grfMode, ppprstg); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Create(ref rfmtid, pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Span rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(ref rfmtid.GetPinnableReference(), pclsid, grfFlags, grfMode, ref ppprstg); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Span rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pclsid, uint grfFlags, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(ref rfmtid.GetPinnableReference(), in pclsid.GetPinnableReference(), grfFlags, grfMode, ppprstg); + } + + /// To be documented. + public static int Create(this ComPtr thisVtbl, ref Guid rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pclsid, uint grfFlags, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Create(ref rfmtid, in pclsid, grfFlags, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Create(this ComPtr thisVtbl, Span rfmtid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pclsid, uint grfFlags, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Create(ref rfmtid.GetPinnableReference(), in pclsid.GetPinnableReference(), grfFlags, grfMode, ref ppprstg); + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, Guid* rfmtid, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Open(rfmtid, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, Span rfmtid, uint grfMode, IPropertyStorage** ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Open(ref rfmtid.GetPinnableReference(), grfMode, ppprstg); + } + + /// To be documented. + public static int Open(this ComPtr thisVtbl, ref Guid rfmtid, uint grfMode, ref ComPtr ppprstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Open(ref rfmtid, grfMode, (IPropertyStorage**) ppprstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Open(this ComPtr thisVtbl, Span rfmtid, uint grfMode, ref IPropertyStorage* ppprstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Open(ref rfmtid.GetPinnableReference(), grfMode, ref ppprstg); + } + + /// To be documented. + public static int Delete(this ComPtr thisVtbl, Span rfmtid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Delete(ref rfmtid.GetPinnableReference()); + } + + /// To be documented. + public static int Enum(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Enum((IEnumSTATPROPSETSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..88c5f563aa --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PropertyStorageVtblExtensions.gen.cs @@ -0,0 +1,768 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PropertyStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int ReadMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, PropVariant* rgpropvar) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspec, rgpropvar); + return ret; + } + + /// To be documented. + public static unsafe int ReadMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, ref PropVariant rgpropvar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspec, rgpropvarPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ReadMultiple(this ComPtr thisVtbl, uint cpspec, ref PropSpec rgpspec, PropVariant* rgpropvar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspecPtr, rgpropvar); + } + return ret; + } + + /// To be documented. + public static int ReadMultiple(this ComPtr thisVtbl, uint cpspec, ref PropSpec rgpspec, ref PropVariant rgpropvar) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cpspec, rgpspecPtr, rgpropvarPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, PropVariant* rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspec, rgpropvar, propidNameFirst); + return ret; + } + + /// To be documented. + public static unsafe int WriteMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, ref PropVariant rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspec, rgpropvarPtr, propidNameFirst); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteMultiple(this ComPtr thisVtbl, uint cpspec, ref PropSpec rgpspec, PropVariant* rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspecPtr, rgpropvar, propidNameFirst); + } + return ret; + } + + /// To be documented. + public static int WriteMultiple(this ComPtr thisVtbl, uint cpspec, ref PropSpec rgpspec, ref PropVariant rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + fixed (PropVariant* rgpropvarPtr = &rgpropvar) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, cpspec, rgpspecPtr, rgpropvarPtr, propidNameFirst); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DeleteMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, cpspec, rgpspec); + return ret; + } + + /// To be documented. + public static int DeleteMultiple(this ComPtr thisVtbl, uint cpspec, ref PropSpec rgpspec) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (PropSpec* rgpspecPtr = &rgpspec) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, cpspec, rgpspecPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropid, rglpwstrName); + return ret; + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropid, rglpwstrNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropidPtr, rglpwstrName); + } + return ret; + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cpropid, rgpropidPtr, rglpwstrNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropid, rglpwstrName); + return ret; + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropid, rglpwstrNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropidPtr, rglpwstrName); + } + return ret; + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + fixed (char** rglpwstrNamePtr = &rglpwstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, cpropid, rgpropidPtr, rglpwstrNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DeletePropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, cpropid, rgpropid); + return ret; + } + + /// To be documented. + public static int DeletePropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* rgpropidPtr = &rgpropid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, cpropid, rgpropidPtr); + } + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl, uint grfCommitFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public static int Revert(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, IEnumSTATPROPSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, ref IEnumSTATPROPSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATPROPSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patime, pmtime); + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patime, pmtimePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patimePtr, pmtime); + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctime, patimePtr, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patime, pmtime); + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public static int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pctimePtr, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetClass(this ComPtr thisVtbl, Guid* clsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, clsid); + return ret; + } + + /// To be documented. + public static int SetClass(this ComPtr thisVtbl, ref Guid clsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidPtr = &clsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, clsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Stat(this ComPtr thisVtbl, STATPROPSETSTG* pstatpsstg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pstatpsstg); + return ret; + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, ref STATPROPSETSTG pstatpsstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATPROPSETSTG* pstatpsstgPtr = &pstatpsstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pstatpsstgPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int ReadMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, Span rgpropvar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadMultiple(cpspec, rgpspec, ref rgpropvar.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int ReadMultiple(this ComPtr thisVtbl, uint cpspec, Span rgpspec, PropVariant* rgpropvar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadMultiple(cpspec, ref rgpspec.GetPinnableReference(), rgpropvar); + } + + /// To be documented. + public static int ReadMultiple(this ComPtr thisVtbl, uint cpspec, Span rgpspec, Span rgpropvar) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadMultiple(cpspec, ref rgpspec.GetPinnableReference(), ref rgpropvar.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteMultiple(this ComPtr thisVtbl, uint cpspec, PropSpec* rgpspec, Span rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteMultiple(cpspec, rgpspec, ref rgpropvar.GetPinnableReference(), propidNameFirst); + } + + /// To be documented. + public static unsafe int WriteMultiple(this ComPtr thisVtbl, uint cpspec, Span rgpspec, PropVariant* rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteMultiple(cpspec, ref rgpspec.GetPinnableReference(), rgpropvar, propidNameFirst); + } + + /// To be documented. + public static int WriteMultiple(this ComPtr thisVtbl, uint cpspec, Span rgpspec, Span rgpropvar, uint propidNameFirst) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteMultiple(cpspec, ref rgpspec.GetPinnableReference(), ref rgpropvar.GetPinnableReference(), propidNameFirst); + } + + /// To be documented. + public static int DeleteMultiple(this ComPtr thisVtbl, uint cpspec, Span rgpspec) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DeleteMultiple(cpspec, ref rgpspec.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, string[] rglpwstrNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->ReadPropertyNames(cpropid, rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public static int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, string[] rglpwstrNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->ReadPropertyNames(cpropid, ref rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, Span rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadPropertyNames(cpropid, ref rgpropid.GetPinnableReference(), rglpwstrName); + } + + /// To be documented. + public static unsafe int ReadPropertyNames(this ComPtr thisVtbl, uint cpropid, Span rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadPropertyNames(cpropid, ref rgpropid.GetPinnableReference(), ref rglpwstrName); + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, uint* rgpropid, string[] rglpwstrNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->WritePropertyNames(cpropid, rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public static int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, ref uint rgpropid, string[] rglpwstrNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rglpwstrName = (char**) SilkMarshal.StringArrayToPtr(rglpwstrNameSa); + var ret = @this->WritePropertyNames(cpropid, ref rgpropid, rglpwstrName); + SilkMarshal.CopyPtrToStringArray((nint) rglpwstrName, rglpwstrNameSa); + SilkMarshal.Free((nint) rglpwstrName); + return ret; + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, Span rgpropid, char** rglpwstrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WritePropertyNames(cpropid, ref rgpropid.GetPinnableReference(), rglpwstrName); + } + + /// To be documented. + public static unsafe int WritePropertyNames(this ComPtr thisVtbl, uint cpropid, Span rgpropid, ref char* rglpwstrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WritePropertyNames(cpropid, ref rgpropid.GetPinnableReference(), ref rglpwstrName); + } + + /// To be documented. + public static int DeletePropertyNames(this ComPtr thisVtbl, uint cpropid, Span rgpropid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DeletePropertyNames(cpropid, ref rgpropid.GetPinnableReference()); + } + + /// To be documented. + public static int Enum(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Enum((IEnumSTATPROPSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(pctime, patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(pctime, in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(pctime, in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(in pctime.GetPinnableReference(), patime, pmtime); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(in pctime.GetPinnableReference(), patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(in pctime.GetPinnableReference(), in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static int SetTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetTimes(in pctime.GetPinnableReference(), in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static int SetClass(this ComPtr thisVtbl, Span clsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetClass(ref clsid.GetPinnableReference()); + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, Span pstatpsstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Stat(ref pstatpsstg.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfo2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfo2VtblExtensions.gen.cs new file mode 100644 index 0000000000..cb7d183753 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfo2VtblExtensions.gen.cs @@ -0,0 +1,179 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ProvideClassInfo2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ITypeInfo** ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ref ITypeInfo* ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, Guid* pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUID); + return ret; + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, ref Guid pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassInfoA(this ComPtr thisVtbl, ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, Span pGUID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGUID(dwGuidKind, ref pGUID.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..fc9d625b7b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideClassInfoVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ProvideClassInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ITypeInfo** ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ref ITypeInfo* ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassInfoA(this ComPtr thisVtbl, ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideMultipleClassInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideMultipleClassInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..faea63cfdf --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProvideMultipleClassInfoVtblExtensions.gen.cs @@ -0,0 +1,1104 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ProvideMultipleClassInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ITypeInfo** ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTI); + return ret; + } + + /// To be documented. + public static unsafe int GetClassInfoA(this ComPtr thisVtbl, ref ITypeInfo* ppTI) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTIPtr = &ppTI) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTIPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, Guid* pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUID); + return ret; + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, ref Guid pGUID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pGUIDPtr = &pGUID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwGuidKind, pGUIDPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMultiTypeInfoCount(this ComPtr thisVtbl, uint* pcti) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pcti); + return ret; + } + + /// To be documented. + public static int GetMultiTypeInfoCount(this ComPtr thisVtbl, ref uint pcti) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pctiPtr = &pcti) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pctiPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSourcePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSource); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClass, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlags, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSource); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimary, piidSourcePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReserved, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSource); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimary, piidSourcePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSource); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** pptiCoClassPtr = &pptiCoClass) + { + fixed (uint* pdwTIFlagsPtr = &pdwTIFlags) + { + fixed (uint* pcdispidReservedPtr = &pcdispidReserved) + { + fixed (Guid* piidPrimaryPtr = &piidPrimary) + { + fixed (Guid* piidSourcePtr = &piidSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, iti, dwFlags, pptiCoClassPtr, pdwTIFlagsPtr, pcdispidReservedPtr, piidPrimaryPtr, piidSourcePtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassInfoA(this ComPtr thisVtbl, ref ComPtr ppTI) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetClassInfoA((ITypeInfo**) ppTI.GetAddressOf()); + } + + /// To be documented. + public static int GetGUID(this ComPtr thisVtbl, uint dwGuidKind, Span pGUID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGUID(dwGuidKind, ref pGUID.GetPinnableReference()); + } + + /// To be documented. + public static int GetMultiTypeInfoCount(this ComPtr thisVtbl, Span pcti) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMultiTypeInfoCount(ref pcti.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, uint* pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), pdwTIFlags, ref pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, uint* pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, Guid* piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, Guid* piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, ref piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ITypeInfo** pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ComPtr pptiCoClass, ref uint pdwTIFlags, ref uint pcdispidReserved, ref Guid piidPrimary, ref Guid piidSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetInfoOfIndex(iti, dwFlags, (ITypeInfo**) pptiCoClass.GetAddressOf(), ref pdwTIFlags, ref pcdispidReserved, ref piidPrimary, ref piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, pcdispidReserved, ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, pcdispidReserved, ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, uint* pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, pdwTIFlags, ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, uint* pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), pcdispidReserved, ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), piidPrimary, piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Guid* piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), piidPrimary, ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Guid* piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), piidSource); + } + + /// To be documented. + public static unsafe int GetInfoOfIndex(this ComPtr thisVtbl, uint iti, uint dwFlags, ref ITypeInfo* pptiCoClass, Span pdwTIFlags, Span pcdispidReserved, Span piidPrimary, Span piidSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetInfoOfIndex(iti, dwFlags, ref pptiCoClass, ref pdwTIFlags.GetPinnableReference(), ref pcdispidReserved.GetPinnableReference(), ref piidPrimary.GetPinnableReference(), ref piidSource.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/QAControl.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/QAControl.gen.cs new file mode 100644 index 0000000000..dd52ec82b0 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/QAControl.gen.cs @@ -0,0 +1,94 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagQACONTROL")] + public unsafe partial struct QAControl + { + public QAControl + ( + uint? cbSize = null, + uint? dwMiscStatus = null, + uint? dwViewStatus = null, + uint? dwEventCookie = null, + uint? dwPropNotifyCookie = null, + uint? dwPointerActivationPolicy = null + ) : this() + { + if (cbSize is not null) + { + CbSize = cbSize.Value; + } + + if (dwMiscStatus is not null) + { + DwMiscStatus = dwMiscStatus.Value; + } + + if (dwViewStatus is not null) + { + DwViewStatus = dwViewStatus.Value; + } + + if (dwEventCookie is not null) + { + DwEventCookie = dwEventCookie.Value; + } + + if (dwPropNotifyCookie is not null) + { + DwPropNotifyCookie = dwPropNotifyCookie.Value; + } + + if (dwPointerActivationPolicy is not null) + { + DwPointerActivationPolicy = dwPointerActivationPolicy.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cbSize")] + public uint CbSize; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwMiscStatus")] + public uint DwMiscStatus; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwViewStatus")] + public uint DwViewStatus; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwEventCookie")] + public uint DwEventCookie; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwPropNotifyCookie")] + public uint DwPropNotifyCookie; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwPointerActivationPolicy")] + public uint DwPointerActivationPolicy; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/RecordInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RecordInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..d003360357 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RecordInfoVtblExtensions.gen.cs @@ -0,0 +1,1854 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class RecordInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int RecordInit(this ComPtr thisVtbl, void* pvNew) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvNew); + return ret; + } + + /// To be documented. + public static int RecordInit(this ComPtr thisVtbl, ref T0 pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvNewPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RecordClear(this ComPtr thisVtbl, void* pvExisting) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvExisting); + return ret; + } + + /// To be documented. + public static int RecordClear(this ComPtr thisVtbl, ref T0 pvExisting) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvExistingPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RecordCopy(this ComPtr thisVtbl, void* pvExisting, void* pvNew) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExisting, pvNew); + return ret; + } + + /// To be documented. + public static unsafe int RecordCopy(this ComPtr thisVtbl, void* pvExisting, ref T0 pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExisting, pvNewPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RecordCopy(this ComPtr thisVtbl, ref T0 pvExisting, void* pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExistingPtr, pvNew); + } + return ret; + } + + /// To be documented. + public static int RecordCopy(this ComPtr thisVtbl, ref T0 pvExisting, ref T1 pvNew) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvExistingPtr = &pvExisting) + { + fixed (void* pvNewPtr = &pvNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvExistingPtr, pvNewPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetGuid(this ComPtr thisVtbl, Guid* pguid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pguid); + return ret; + } + + /// To be documented. + public static int GetGuid(this ComPtr thisVtbl, ref Guid pguid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPtr = &pguid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pguidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetName(this ComPtr thisVtbl, char** pbstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetName(this ComPtr thisVtbl, ref char* pbstrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrNamePtr = &pbstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbstrNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pcbSize); + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, ITypeInfo** ppTypeInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppTypeInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, ref ITypeInfo* ppTypeInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTypeInfoPtr = &ppTypeInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppTypeInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public static int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static int GetField(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarField, ppvDataCArray); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarField, ppvDataCArrayPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarFieldPtr, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldName, pvarFieldPtr, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArray); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvData, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarField, ppvDataCArray); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarField, ppvDataCArrayPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarFieldPtr, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldName, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArray); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArray); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarField, ppvDataCArrayPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArray); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + fixed (void** ppvDataCArrayPtr = &ppvDataCArray) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvDataPtr, szFieldNamePtr, pvarFieldPtr, ppvDataCArrayPtr); + } + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public static int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static int PutField(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldName, pvarField); + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldName, pvarFieldPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) + { + var @this = thisVtbl.Handle; + int ret = default; + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvData, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldName, pvarField); + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldName, pvarFieldPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + } + } + return ret; + } + + /// To be documented. + public static int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + fixed (char* szFieldNamePtr = &szFieldName) + { + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarField); + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, ref T0 pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, ref Variant pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + var szFieldNamePtr = (byte*) SilkMarshal.StringToPtr(szFieldName, NativeStringEncoding.UTF8); + fixed (Variant* pvarFieldPtr = &pvarField) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, wFlags, pvDataPtr, szFieldNamePtr, pvarFieldPtr); + } + SilkMarshal.Free((nint)szFieldNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, uint* pcNames, char** rgBstrNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNames, rgBstrNames); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, uint* pcNames, ref char* rgBstrNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNames, rgBstrNamesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, ref uint pcNames, char** rgBstrNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNamesPtr, rgBstrNames); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, ref uint pcNames, ref char* rgBstrNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcNamesPtr, rgBstrNamesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe Silk.NET.Core.Bool32 IsMatchingType(this ComPtr thisVtbl, IRecordInfo* pRecordInfo) + { + var @this = thisVtbl.Handle; + Silk.NET.Core.Bool32 ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pRecordInfo); + return ret; + } + + /// To be documented. + public static Silk.NET.Core.Bool32 IsMatchingType(this ComPtr thisVtbl, ref IRecordInfo pRecordInfo) + { + var @this = thisVtbl.Handle; + Silk.NET.Core.Bool32 ret = default; + fixed (IRecordInfo* pRecordInfoPtr = &pRecordInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pRecordInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe void* RecordCreate(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this); + return ret; + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, void* pvSource, void** ppvDest) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSource, ppvDest); + return ret; + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, void* pvSource, ref void* ppvDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvDestPtr = &ppvDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSource, ppvDestPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, ref T0 pvSource, void** ppvDest) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvSourcePtr = &pvSource) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSourcePtr, ppvDest); + } + return ret; + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, ref T0 pvSource, ref void* ppvDest) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvSourcePtr = &pvSource) + { + fixed (void** ppvDestPtr = &ppvDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pvSourcePtr, ppvDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int RecordDestroy(this ComPtr thisVtbl, void* pvRecord) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pvRecord); + return ret; + } + + /// To be documented. + public static int RecordDestroy(this ComPtr thisVtbl, ref T0 pvRecord) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvRecordPtr = &pvRecord) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pvRecordPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int RecordInit(this ComPtr thisVtbl, Span pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordInit(ref pvNew.GetPinnableReference()); + } + + /// To be documented. + public static int RecordClear(this ComPtr thisVtbl, Span pvExisting) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordClear(ref pvExisting.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RecordCopy(this ComPtr thisVtbl, void* pvExisting, Span pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordCopy(pvExisting, ref pvNew.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RecordCopy(this ComPtr thisVtbl, Span pvExisting, void* pvNew) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordCopy(ref pvExisting.GetPinnableReference(), pvNew); + } + + /// To be documented. + public static int RecordCopy(this ComPtr thisVtbl, Span pvExisting, Span pvNew) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordCopy(ref pvExisting.GetPinnableReference(), ref pvNew.GetPinnableReference()); + } + + /// To be documented. + public static int GetGuid(this ComPtr thisVtbl, Span pguid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGuid(ref pguid.GetPinnableReference()); + } + + /// To be documented. + public static int GetName(this ComPtr thisVtbl, string[] pbstrNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrName = (char**) SilkMarshal.StringArrayToPtr(pbstrNameSa); + var ret = @this->GetName(pbstrName); + SilkMarshal.CopyPtrToStringArray((nint) pbstrName, pbstrNameSa); + SilkMarshal.Free((nint) pbstrName); + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span pcbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeInfo(this ComPtr thisVtbl, ref ComPtr ppTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfo((ITypeInfo**) ppTypeInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(pvData, in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(pvData, in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static int GetField(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetField(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, szFieldName, ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, szFieldName, ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, in szFieldName.GetPinnableReference(), pvarField, ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, in szFieldName.GetPinnableReference(), pvarField, ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField, void** ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, szFieldName, ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField, ref void* ppvDataCArray) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(pvData, szFieldName, ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, pvarField, ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, pvarField, ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), pvarField, ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), pvarField, ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, pvarField, ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, pvarField, ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField, void** ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference(), ppvDataCArray); + } + + /// To be documented. + public static unsafe int GetFieldNoCopy(this ComPtr thisVtbl, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField, ref void* ppvDataCArray) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNoCopy(ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference(), ref ppvDataCArray); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, pvData, in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, pvData, in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static int PutField(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutField(wFlags, ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, pvData, in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, pvData, in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, void* pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, pvData, szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), pvarField); + } + + /// To be documented. + public static int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), in szFieldName.GetPinnableReference(), ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Variant* pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), szFieldName, pvarField); + } + + /// To be documented. + public static int PutFieldNoCopy(this ComPtr thisVtbl, uint wFlags, Span pvData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szFieldName, Span pvarField) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PutFieldNoCopy(wFlags, ref pvData.GetPinnableReference(), szFieldName, ref pvarField.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, uint* pcNames, string[] rgBstrNamesSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetFieldNames(pcNames, rgBstrNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static int GetFieldNames(this ComPtr thisVtbl, ref uint pcNames, string[] rgBstrNamesSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetFieldNames(ref pcNames, rgBstrNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, Span pcNames, char** rgBstrNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNames(ref pcNames.GetPinnableReference(), rgBstrNames); + } + + /// To be documented. + public static unsafe int GetFieldNames(this ComPtr thisVtbl, Span pcNames, ref char* rgBstrNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFieldNames(ref pcNames.GetPinnableReference(), ref rgBstrNames); + } + + /// To be documented. + public static Silk.NET.Core.Bool32 IsMatchingType(this ComPtr thisVtbl, ComPtr pRecordInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsMatchingType((IRecordInfo*) pRecordInfo.Handle); + } + + /// To be documented. + public static Silk.NET.Core.Bool32 IsMatchingType(this ComPtr thisVtbl, Span pRecordInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsMatchingType(ref pRecordInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, Span pvSource, void** ppvDest) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordCreateCopy(ref pvSource.GetPinnableReference(), ppvDest); + } + + /// To be documented. + public static unsafe int RecordCreateCopy(this ComPtr thisVtbl, Span pvSource, ref void* ppvDest) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordCreateCopy(ref pvSource.GetPinnableReference(), ref ppvDest); + } + + /// To be documented. + public static int RecordDestroy(this ComPtr thisVtbl, Span pvRecord) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RecordDestroy(ref pvRecord.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSETSTG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSETSTG.gen.cs new file mode 100644 index 0000000000..f20cce930b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSETSTG.gen.cs @@ -0,0 +1,105 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSTATPROPSETSTG")] + public unsafe partial struct STATPROPSETSTG + { + public STATPROPSETSTG + ( + Guid? fmtid = null, + Guid? clsid = null, + uint? grfFlags = null, + Silk.NET.Core.Win32Extras.Filetime? mtime = null, + Silk.NET.Core.Win32Extras.Filetime? ctime = null, + Silk.NET.Core.Win32Extras.Filetime? atime = null, + uint? dwOSVersion = null + ) : this() + { + if (fmtid is not null) + { + Fmtid = fmtid.Value; + } + + if (clsid is not null) + { + Clsid = clsid.Value; + } + + if (grfFlags is not null) + { + GrfFlags = grfFlags.Value; + } + + if (mtime is not null) + { + Mtime = mtime.Value; + } + + if (ctime is not null) + { + Ctime = ctime.Value; + } + + if (atime is not null) + { + Atime = atime.Value; + } + + if (dwOSVersion is not null) + { + DwOSVersion = dwOSVersion.Value; + } + } + + + [NativeName("Type", "FMTID")] + [NativeName("Type.Name", "FMTID")] + [NativeName("Name", "fmtid")] + public Guid Fmtid; + + [NativeName("Type", "CLSID")] + [NativeName("Type.Name", "CLSID")] + [NativeName("Name", "clsid")] + public Guid Clsid; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "grfFlags")] + public uint GrfFlags; + + [NativeName("Type", "FILETIME")] + [NativeName("Type.Name", "FILETIME")] + [NativeName("Name", "mtime")] + public Silk.NET.Core.Win32Extras.Filetime Mtime; + + [NativeName("Type", "FILETIME")] + [NativeName("Type.Name", "FILETIME")] + [NativeName("Name", "ctime")] + public Silk.NET.Core.Win32Extras.Filetime Ctime; + + [NativeName("Type", "FILETIME")] + [NativeName("Type.Name", "FILETIME")] + [NativeName("Name", "atime")] + public Silk.NET.Core.Win32Extras.Filetime Atime; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwOSVersion")] + public uint DwOSVersion; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSTG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSTG.gen.cs new file mode 100644 index 0000000000..80107f2305 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATPROPSTG.gen.cs @@ -0,0 +1,62 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagSTATPROPSTG")] + public unsafe partial struct STATPROPSTG + { + public STATPROPSTG + ( + char* lpwstrName = null, + uint? propid = null, + ushort? vt = null + ) : this() + { + if (lpwstrName is not null) + { + LpwstrName = lpwstrName; + } + + if (propid is not null) + { + Propid = propid.Value; + } + + if (vt is not null) + { + Vt = vt.Value; + } + } + + + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "lpwstrName")] + public char* LpwstrName; + + [NativeName("Type", "PROPID")] + [NativeName("Type.Name", "PROPID")] + [NativeName("Name", "propid")] + public uint Propid; + + [NativeName("Type", "VARTYPE")] + [NativeName("Type.Name", "VARTYPE")] + [NativeName("Name", "vt")] + public ushort Vt; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/SerializedPropertyValue.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/SerializedPropertyValue.gen.cs new file mode 100644 index 0000000000..ff2d74088f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/SerializedPropertyValue.gen.cs @@ -0,0 +1,43 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSERIALIZEDPROPERTYVALUE")] + public unsafe partial struct SerializedPropertyValue + { + public SerializedPropertyValue + ( + uint? dwType = null + ) : this() + { + if (dwType is not null) + { + DwType = dwType.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwType")] + public uint DwType; + [NativeName("Type", "BYTE[1]")] + [NativeName("Type.Name", "BYTE[1]")] + [NativeName("Name", "rgb")] + public fixed byte Rgb[1]; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/SpecifyPropertyPagesVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/SpecifyPropertyPagesVtblExtensions.gen.cs new file mode 100644 index 0000000000..4d568c175d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/SpecifyPropertyPagesVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class SpecifyPropertyPagesVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetPages(this ComPtr thisVtbl, CAUUID* pPages) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPages); + return ret; + } + + /// To be documented. + public static int GetPages(this ComPtr thisVtbl, ref CAUUID pPages) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CAUUID* pPagesPtr = &pPages) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPagesPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetPages(this ComPtr thisVtbl, Span pPages) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPages(ref pPages.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/SupportErrorInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/SupportErrorInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..3cde36294f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/SupportErrorInfoVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class SupportErrorInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int InterfaceSupportsErrorInfo(this ComPtr thisVtbl, Guid* riid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, riid); + return ret; + } + + /// To be documented. + public static int InterfaceSupportsErrorInfo(this ComPtr thisVtbl, ref Guid riid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, riidPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int InterfaceSupportsErrorInfo(this ComPtr thisVtbl, Span riid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InterfaceSupportsErrorInfo(ref riid.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TLibAttr.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TLibAttr.gen.cs new file mode 100644 index 0000000000..8ada46945d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TLibAttr.gen.cs @@ -0,0 +1,94 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagTLIBATTR")] + public unsafe partial struct TLibAttr + { + public TLibAttr + ( + Guid? guid = null, + uint? lcid = null, + SysKind? syskind = null, + ushort? wMajorVerNum = null, + ushort? wMinorVerNum = null, + ushort? wLibFlags = null + ) : this() + { + if (guid is not null) + { + Guid = guid.Value; + } + + if (lcid is not null) + { + Lcid = lcid.Value; + } + + if (syskind is not null) + { + Syskind = syskind.Value; + } + + if (wMajorVerNum is not null) + { + WMajorVerNum = wMajorVerNum.Value; + } + + if (wMinorVerNum is not null) + { + WMinorVerNum = wMinorVerNum.Value; + } + + if (wLibFlags is not null) + { + WLibFlags = wLibFlags.Value; + } + } + + + [NativeName("Type", "GUID")] + [NativeName("Type.Name", "GUID")] + [NativeName("Name", "guid")] + public Guid Guid; + + [NativeName("Type", "LCID")] + [NativeName("Type.Name", "LCID")] + [NativeName("Name", "lcid")] + public uint Lcid; + + [NativeName("Type", "SYSKIND")] + [NativeName("Type.Name", "SYSKIND")] + [NativeName("Name", "syskind")] + public SysKind Syskind; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wMajorVerNum")] + public ushort WMajorVerNum; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wMinorVerNum")] + public ushort WMinorVerNum; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wLibFlags")] + public ushort WLibFlags; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/Tagpropertykey.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/Tagpropertykey.gen.cs new file mode 100644 index 0000000000..e1e665e844 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/Tagpropertykey.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "_tagpropertykey")] + public unsafe partial struct Tagpropertykey + { + public Tagpropertykey + ( + Guid? fmtid = null, + uint? pid = null + ) : this() + { + if (fmtid is not null) + { + Fmtid = fmtid.Value; + } + + if (pid is not null) + { + Pid = pid.Value; + } + } + + + [NativeName("Type", "GUID")] + [NativeName("Type.Name", "GUID")] + [NativeName("Name", "fmtid")] + public Guid Fmtid; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "pid")] + public uint Pid; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeAttr.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeAttr.gen.cs new file mode 100644 index 0000000000..66af00318a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeAttr.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagTYPEATTR")] + public unsafe partial struct TypeAttr + { + public TypeAttr + ( + Guid? guid = null, + uint? lcid = null, + uint? dwReserved = null, + int? memidConstructor = null, + int? memidDestructor = null, + char* lpstrSchema = null, + uint? cbSizeInstance = null, + TypeKind? typekind = null, + ushort? cFuncs = null, + ushort? cVars = null, + ushort? cImplTypes = null, + ushort? cbSizeVft = null, + ushort? cbAlignment = null, + ushort? wTypeFlags = null, + ushort? wMajorVerNum = null, + ushort? wMinorVerNum = null, + TypeDesc? tdescAlias = null, + IdlDesc? idldescType = null + ) : this() + { + if (guid is not null) + { + Guid = guid.Value; + } + + if (lcid is not null) + { + Lcid = lcid.Value; + } + + if (dwReserved is not null) + { + DwReserved = dwReserved.Value; + } + + if (memidConstructor is not null) + { + MemidConstructor = memidConstructor.Value; + } + + if (memidDestructor is not null) + { + MemidDestructor = memidDestructor.Value; + } + + if (lpstrSchema is not null) + { + LpstrSchema = lpstrSchema; + } + + if (cbSizeInstance is not null) + { + CbSizeInstance = cbSizeInstance.Value; + } + + if (typekind is not null) + { + Typekind = typekind.Value; + } + + if (cFuncs is not null) + { + CFuncs = cFuncs.Value; + } + + if (cVars is not null) + { + CVars = cVars.Value; + } + + if (cImplTypes is not null) + { + CImplTypes = cImplTypes.Value; + } + + if (cbSizeVft is not null) + { + CbSizeVft = cbSizeVft.Value; + } + + if (cbAlignment is not null) + { + CbAlignment = cbAlignment.Value; + } + + if (wTypeFlags is not null) + { + WTypeFlags = wTypeFlags.Value; + } + + if (wMajorVerNum is not null) + { + WMajorVerNum = wMajorVerNum.Value; + } + + if (wMinorVerNum is not null) + { + WMinorVerNum = wMinorVerNum.Value; + } + + if (tdescAlias is not null) + { + TdescAlias = tdescAlias.Value; + } + + if (idldescType is not null) + { + IdldescType = idldescType.Value; + } + } + + + [NativeName("Type", "GUID")] + [NativeName("Type.Name", "GUID")] + [NativeName("Name", "guid")] + public Guid Guid; + + [NativeName("Type", "LCID")] + [NativeName("Type.Name", "LCID")] + [NativeName("Name", "lcid")] + public uint Lcid; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwReserved")] + public uint DwReserved; + + [NativeName("Type", "MEMBERID")] + [NativeName("Type.Name", "MEMBERID")] + [NativeName("Name", "memidConstructor")] + public int MemidConstructor; + + [NativeName("Type", "MEMBERID")] + [NativeName("Type.Name", "MEMBERID")] + [NativeName("Name", "memidDestructor")] + public int MemidDestructor; + + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "lpstrSchema")] + public char* LpstrSchema; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cbSizeInstance")] + public uint CbSizeInstance; + + [NativeName("Type", "TYPEKIND")] + [NativeName("Type.Name", "TYPEKIND")] + [NativeName("Name", "typekind")] + public TypeKind Typekind; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "cFuncs")] + public ushort CFuncs; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "cVars")] + public ushort CVars; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "cImplTypes")] + public ushort CImplTypes; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "cbSizeVft")] + public ushort CbSizeVft; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "cbAlignment")] + public ushort CbAlignment; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wTypeFlags")] + public ushort WTypeFlags; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wMajorVerNum")] + public ushort WMajorVerNum; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wMinorVerNum")] + public ushort WMinorVerNum; + + [NativeName("Type", "TYPEDESC")] + [NativeName("Type.Name", "TYPEDESC")] + [NativeName("Name", "tdescAlias")] + public TypeDesc TdescAlias; + + [NativeName("Type", "IDLDESC")] + [NativeName("Type.Name", "IDLDESC")] + [NativeName("Name", "idldescType")] + public IdlDesc IdldescType; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeChangeEventsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeChangeEventsVtblExtensions.gen.cs new file mode 100644 index 0000000000..40caf0512b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeChangeEventsVtblExtensions.gen.cs @@ -0,0 +1,542 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeChangeEventsVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, char* pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrName, pfCancel); + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, char* pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrName, pfCancelPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, ref char pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancel); + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, ref char pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancelPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancel); + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBefore, pStrNamePtr, pfCancelPtr); + } + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, char* pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrName, pfCancel); + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, char* pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrName, pfCancelPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, ref char pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancel); + } + } + return ret; + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, ref char pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + fixed (char* pStrNamePtr = &pStrName) + { + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancelPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancel); + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoBeforePtr = &pTInfoBefore) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + fixed (int* pfCancelPtr = &pfCancel) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, changeKind, pTInfoBeforePtr, pStrNamePtr, pfCancelPtr); + } + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoAfter, char* pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrName); + return ret; + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoAfter, ref char pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfter, pStrNamePtr); + SilkMarshal.Free((nint)pStrNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoAfter, char* pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrName); + } + return ret; + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoAfter, ref char pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + fixed (char* pStrNamePtr = &pStrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrNamePtr); + } + } + return ret; + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ref ITypeInfo pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTInfoAfterPtr = &pTInfoAfter) + { + var pStrNamePtr = (byte*) SilkMarshal.StringToPtr(pStrName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, changeKind, pTInfoAfterPtr, pStrNamePtr); + SilkMarshal.Free((nint)pStrNamePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, char* pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, char* pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, pTInfoBefore, pStrName, ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, char* pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, ref pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, Span pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, pTInfoBefore, ref pStrName.GetPinnableReference(), pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, ref char pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, ref pStrName, pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, Span pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, pTInfoBefore, ref pStrName.GetPinnableReference(), ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, ref char pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, ref pStrName, ref pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, pTInfoBefore, pStrName, ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, ref int pfCancel) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RequestTypeChange(changeKind, (ITypeInfo*) pTInfoBefore.Handle, pStrName, ref pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, char* pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), pStrName, pfCancel); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, char* pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), pStrName, ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, Span pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), ref pStrName.GetPinnableReference(), pfCancel); + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, Span pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), ref pStrName.GetPinnableReference(), ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, int* pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), pStrName, pfCancel); + } + + /// To be documented. + public static int RequestTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoBefore, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName, Span pfCancel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RequestTypeChange(changeKind, ref pTInfoBefore.GetPinnableReference(), pStrName, ref pfCancel.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoAfter, char* pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, pStrName); + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ITypeInfo* pTInfoAfter, Span pStrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AfterTypeChange(changeKind, pTInfoAfter, ref pStrName.GetPinnableReference()); + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoAfter, ref char pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, ref pStrName); + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, ComPtr pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AfterTypeChange(changeKind, (ITypeInfo*) pTInfoAfter.Handle, pStrName); + } + + /// To be documented. + public static unsafe int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoAfter, char* pStrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AfterTypeChange(changeKind, ref pTInfoAfter.GetPinnableReference(), pStrName); + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoAfter, Span pStrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AfterTypeChange(changeKind, ref pTInfoAfter.GetPinnableReference(), ref pStrName.GetPinnableReference()); + } + + /// To be documented. + public static int AfterTypeChange(this ComPtr thisVtbl, ChangeKind changeKind, Span pTInfoAfter, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pStrName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AfterTypeChange(changeKind, ref pTInfoAfter.GetPinnableReference(), pStrName); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeCompVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeCompVtblExtensions.gen.cs new file mode 100644 index 0000000000..94d7db5b64 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeCompVtblExtensions.gen.cs @@ -0,0 +1,1009 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeCompVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szName, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtrPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfo, pDescKindPtr, pBindPtrPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKind, pBindPtrPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (DescKind* pDescKindPtr = &pDescKind) + { + fixed (BindPtr* pBindPtrPtr = &pBindPtr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, szNamePtr, lHashVal, wFlags, ppTInfoPtr, pDescKindPtr, pBindPtrPtr); + } + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfo, ppTComp); + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfo, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfoPtr, ppTComp); + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szName, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTComp); + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTCompPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTComp); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNamePtr = &szName) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTComp); + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfo, ppTCompPtr); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTComp); + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNamePtr = (byte*) SilkMarshal.StringToPtr(szName, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, szNamePtr, lHashVal, ppTInfoPtr, ppTCompPtr); + } + } + SilkMarshal.Free((nint)szNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static int Bind(this ComPtr thisVtbl, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Bind(szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + public static unsafe int Bind(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Bind(szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindType(ref szName.GetPinnableReference(), lHashVal, ppTInfo, ppTComp); + } + + /// To be documented. + public static int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindType(ref szName.GetPinnableReference(), lHashVal, ppTInfo, ref ppTComp); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindType(ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ppTComp); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(ref szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindType(ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ref ppTComp); + } + + /// To be documented. + public static int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); + } + + /// To be documented. + public static unsafe int BindType(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindType(szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDesc.gen.cs new file mode 100644 index 0000000000..56b221508c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDesc.gen.cs @@ -0,0 +1,110 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagTYPEDESC")] + public unsafe partial struct TypeDesc + { + public TypeDesc + ( + TypeDescUnion? anonymous = null, + ushort? vt = null, + TypeDesc* lptdesc = null, + ArrayDesc* lpadesc = null, + uint? hreftype = null + ) : this() + { + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (vt is not null) + { + Vt = vt.Value; + } + + if (lptdesc is not null) + { + Lptdesc = lptdesc; + } + + if (lpadesc is not null) + { + Lpadesc = lpadesc; + } + + if (hreftype is not null) + { + Hreftype = hreftype.Value; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_oaidl_L653_C36")] + [NativeName("Name", "anonymous1")] + public TypeDescUnion Anonymous; + + [NativeName("Type", "VARTYPE")] + [NativeName("Type.Name", "VARTYPE")] + [NativeName("Name", "vt")] + public ushort Vt; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref TypeDesc* Lptdesc + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Lptdesc; + } +#else + public TypeDesc* Lptdesc + { + get => Anonymous.Lptdesc; + set => Anonymous.Lptdesc = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref ArrayDesc* Lpadesc + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Lpadesc; + } +#else + public ArrayDesc* Lpadesc + { + get => Anonymous.Lpadesc; + set => Anonymous.Lpadesc = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint Hreftype + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Hreftype; + } +#else + public uint Hreftype + { + get => Anonymous.Hreftype; + set => Anonymous.Hreftype = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDescUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDescUnion.gen.cs new file mode 100644 index 0000000000..15d13e6644 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeDescUnion.gen.cs @@ -0,0 +1,65 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit)] + [NativeName("Name", "__AnonymousRecord_oaidl_L653_C36")] + public unsafe partial struct TypeDescUnion + { + public TypeDescUnion + ( + TypeDesc* lptdesc = null, + ArrayDesc* lpadesc = null, + uint? hreftype = null + ) : this() + { + if (lptdesc is not null) + { + Lptdesc = lptdesc; + } + + if (lpadesc is not null) + { + Lpadesc = lpadesc; + } + + if (hreftype is not null) + { + Hreftype = hreftype.Value; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "struct tagTYPEDESC *")] + [NativeName("Type.Name", "struct tagTYPEDESC *")] + [NativeName("Name", "lptdesc")] + public TypeDesc* Lptdesc; + + [FieldOffset(0)] + [NativeName("Type", "struct tagARRAYDESC *")] + [NativeName("Type.Name", "struct tagARRAYDESC *")] + [NativeName("Name", "lpadesc")] + public ArrayDesc* Lpadesc; + + [FieldOffset(0)] + [NativeName("Type", "HREFTYPE")] + [NativeName("Type.Name", "HREFTYPE")] + [NativeName("Name", "hreftype")] + public uint Hreftype; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeFactoryVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeFactoryVtblExtensions.gen.cs new file mode 100644 index 0000000000..df75814759 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeFactoryVtblExtensions.gen.cs @@ -0,0 +1,345 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeFactoryVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, Guid* riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riid, ppv); + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riid, ppvPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riidPtr, ppv); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfo, riidPtr, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, Guid* riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riid, ppv); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riid, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riidPtr, ppv); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo* pTypeInfoPtr = &pTypeInfo) + { + fixed (Guid* riidPtr = &riid) + { + fixed (Silk.NET.Core.Native.IUnknown** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pTypeInfoPtr, riidPtr, ppvPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int CreateFromTypeInfo(this ComPtr thisVtbl, ComPtr pTypeInfo, out ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppv = default; + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ComPtr pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, riid, ref ppv); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, Span riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(pTypeInfo, ref riid.GetPinnableReference(), ppv); + } + + /// To be documented. + public static int CreateFromTypeInfo(this ComPtr thisVtbl, ComPtr pTypeInfo, ref Guid riid, ref ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ITypeInfo* pTypeInfo, Span riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(pTypeInfo, ref riid.GetPinnableReference(), ref ppv); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, ComPtr pTypeInfo, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFromTypeInfo((ITypeInfo*) pTypeInfo.Handle, ref riid, ref ppv); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, Span pTypeInfo, Guid* riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo.GetPinnableReference(), riid, ppv); + } + + /// To be documented. + public static int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, out ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppv = default; + return @this->CreateFromTypeInfo(ref pTypeInfo, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, Span pTypeInfo, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo.GetPinnableReference(), riid, ref ppv); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, Span pTypeInfo, Span riid, Silk.NET.Core.Native.IUnknown** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo.GetPinnableReference(), ref riid.GetPinnableReference(), ppv); + } + + /// To be documented. + public static int CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo, ref Guid riid, ref ComPtr ppv) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo, ref riid, (Silk.NET.Core.Native.IUnknown**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFromTypeInfo(this ComPtr thisVtbl, Span pTypeInfo, Span riid, ref Silk.NET.Core.Native.IUnknown* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFromTypeInfo(ref pTypeInfo.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppv); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateFromTypeInfo(this ComPtr thisVtbl, ComPtr pTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateFromTypeInfo(pTypeInfo, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateFromTypeInfo(this ComPtr thisVtbl, ref ITypeInfo pTypeInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateFromTypeInfo(ref pTypeInfo, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfo2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfo2VtblExtensions.gen.cs new file mode 100644 index 0000000000..d375499b82 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfo2VtblExtensions.gen.cs @@ -0,0 +1,3236 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeInfo2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeAttr(this ComPtr thisVtbl, TypeAttr** ppTypeAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttr); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeAttr(this ComPtr thisVtbl, ref TypeAttr* ppTypeAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeAttr** ppTypeAttrPtr = &ppTypeAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTComp); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFuncDesc(this ComPtr thisVtbl, uint index, FuncDesc** ppFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDesc); + return ret; + } + + /// To be documented. + public static unsafe int GetFuncDesc(this ComPtr thisVtbl, uint index, ref FuncDesc* ppFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (FuncDesc** ppFuncDescPtr = &ppFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVarDesc(this ComPtr thisVtbl, uint index, VarDesc** ppVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDesc); + return ret; + } + + /// To be documented. + public static unsafe int GetVarDesc(this ComPtr thisVtbl, uint index, ref VarDesc* ppVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (VarDesc** ppVarDescPtr = &ppVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNames); + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNamesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNames); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNamesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, uint* pRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefType); + return ret; + } + + /// To be documented. + public static int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, ref uint pRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRefTypePtr = &pRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetImplTypeFlags(this ComPtr thisVtbl, uint index, int* pImplTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlags); + return ret; + } + + /// To be documented. + public static int GetImplTypeFlags(this ComPtr thisVtbl, uint index, ref int pImplTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pImplTypeFlagsPtr = &pImplTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemId); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemIdPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemId); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemIdPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinalPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinal); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinal); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinal); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinalPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ITypeInfo** ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ref ITypeInfo* ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddressOfMember(this ComPtr thisVtbl, int memid, InvokeKind invKind, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppv); + return ret; + } + + /// To be documented. + public static unsafe int AddressOfMember(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppvPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObj); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMops(this ComPtr thisVtbl, int memid, char** pBstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMops); + return ret; + } + + /// To be documented. + public static unsafe int GetMops(this ComPtr thisVtbl, int memid, ref char* pBstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrMopsPtr = &pBstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMopsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, uint* pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndex); + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, ref uint pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndexPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, uint* pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndex); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, ref uint pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndexPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe void ReleaseTypeAttr(this ComPtr thisVtbl, TypeAttr* pTypeAttr) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttr); + } + + /// To be documented. + public static void ReleaseTypeAttr(this ComPtr thisVtbl, ref TypeAttr pTypeAttr) + { + var @this = thisVtbl.Handle; + fixed (TypeAttr* pTypeAttrPtr = &pTypeAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttrPtr); + } + } + + /// To be documented. + public static unsafe void ReleaseFuncDesc(this ComPtr thisVtbl, FuncDesc* pFuncDesc) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDesc); + } + + /// To be documented. + public static void ReleaseFuncDesc(this ComPtr thisVtbl, ref FuncDesc pFuncDesc) + { + var @this = thisVtbl.Handle; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDescPtr); + } + } + + /// To be documented. + public static unsafe void ReleaseVarDesc(this ComPtr thisVtbl, VarDesc* pVarDesc) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDesc); + } + + /// To be documented. + public static void ReleaseVarDesc(this ComPtr thisVtbl, ref VarDesc pVarDesc) + { + var @this = thisVtbl.Handle; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDescPtr); + } + } + + /// To be documented. + public static unsafe int GetTypeKind(this ComPtr thisVtbl, TypeKind* pTypeKind) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pTypeKind); + return ret; + } + + /// To be documented. + public static int GetTypeKind(this ComPtr thisVtbl, ref TypeKind pTypeKind) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeKind* pTypeKindPtr = &pTypeKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pTypeKindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeFlags(this ComPtr thisVtbl, uint* pTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, pTypeFlags); + return ret; + } + + /// To be documented. + public static int GetTypeFlags(this ComPtr thisVtbl, ref uint pTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pTypeFlagsPtr = &pTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[23])(@this, pTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFuncIndexOfMemId(this ComPtr thisVtbl, int memid, InvokeKind invKind, uint* pFuncIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, memid, invKind, pFuncIndex); + return ret; + } + + /// To be documented. + public static int GetFuncIndexOfMemId(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref uint pFuncIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pFuncIndexPtr = &pFuncIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[24])(@this, memid, invKind, pFuncIndexPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVarIndexOfMemId(this ComPtr thisVtbl, int memid, uint* pVarIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this, memid, pVarIndex); + return ret; + } + + /// To be documented. + public static int GetVarIndexOfMemId(this ComPtr thisVtbl, int memid, ref uint pVarIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pVarIndexPtr = &pVarIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[25])(@this, memid, pVarIndexPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetCustData(this ComPtr thisVtbl, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[26])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFuncCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetFuncCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[27])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[28])(@this, indexFunc, indexParam, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVarCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetVarCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[29])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetImplTypeCustData(this ComPtr thisVtbl, uint index, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetImplTypeCustData(this ComPtr thisVtbl, uint index, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[30])(@this, index, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[31])(@this, memid, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllCustData(this ComPtr thisVtbl, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllCustData(this ComPtr thisVtbl, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[32])(@this, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllFuncCustData(this ComPtr thisVtbl, uint index, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllFuncCustData(this ComPtr thisVtbl, uint index, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[33])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, indexFunc, indexParam, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[34])(@this, indexFunc, indexParam, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllVarCustData(this ComPtr thisVtbl, uint index, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllVarCustData(this ComPtr thisVtbl, uint index, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[35])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllImplTypeCustData(this ComPtr thisVtbl, uint index, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, index, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllImplTypeCustData(this ComPtr thisVtbl, uint index, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[36])(@this, index, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetTypeComp(this ComPtr thisVtbl, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static int GetNames(this ComPtr thisVtbl, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNames(memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + public static int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, Span pRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetRefTypeOfImplType(index, ref pRefType.GetPinnableReference()); + } + + /// To be documented. + public static int GetImplTypeFlags(this ComPtr thisVtbl, uint index, Span pImplTypeFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetImplTypeFlags(index, ref pImplTypeFlags.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, string[] rgszNamesSa, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static int GetIDsOfNames(this ComPtr thisVtbl, string[] rgszNamesSa, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, Span pMemId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, Span pMemId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetRefTypeInfo(hRefType, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(pUnkOuter, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(pUnkOuter, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance(ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static int GetMops(this ComPtr thisVtbl, int memid, string[] pBstrMopsSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrMops = (char**) SilkMarshal.StringArrayToPtr(pBstrMopsSa); + var ret = @this->GetMops(memid, pBstrMops); + SilkMarshal.CopyPtrToStringArray((nint) pBstrMops, pBstrMopsSa); + SilkMarshal.Free((nint) pBstrMops); + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, Span pIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainingTypeLib(ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + public static int GetContainingTypeLib(this ComPtr thisVtbl, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, Span pIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainingTypeLib(ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseTypeAttr(this ComPtr thisVtbl, Span pTypeAttr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseTypeAttr(ref pTypeAttr.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseFuncDesc(this ComPtr thisVtbl, Span pFuncDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseFuncDesc(ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseVarDesc(this ComPtr thisVtbl, Span pVarDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseVarDesc(ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeKind(this ComPtr thisVtbl, Span pTypeKind) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeKind(ref pTypeKind.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeFlags(this ComPtr thisVtbl, Span pTypeFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeFlags(ref pTypeFlags.GetPinnableReference()); + } + + /// To be documented. + public static int GetFuncIndexOfMemId(this ComPtr thisVtbl, int memid, InvokeKind invKind, Span pFuncIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFuncIndexOfMemId(memid, invKind, ref pFuncIndex.GetPinnableReference()); + } + + /// To be documented. + public static int GetVarIndexOfMemId(this ComPtr thisVtbl, int memid, Span pVarIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVarIndexOfMemId(memid, ref pVarIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetCustData(this ComPtr thisVtbl, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFuncCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFuncCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFuncCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFuncCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetFuncCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFuncCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParamCustData(indexFunc, indexParam, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParamCustData(indexFunc, indexParam, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParamCustData(indexFunc, indexParam, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVarCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVarCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVarCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVarCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetVarCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVarCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetImplTypeCustData(this ComPtr thisVtbl, uint index, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetImplTypeCustData(index, guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetImplTypeCustData(this ComPtr thisVtbl, uint index, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetImplTypeCustData(index, ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetImplTypeCustData(this ComPtr thisVtbl, uint index, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetImplTypeCustData(index, ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public static int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + public static int GetAllCustData(this ComPtr thisVtbl, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllCustData(ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static int GetAllFuncCustData(this ComPtr thisVtbl, uint index, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllFuncCustData(index, ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static int GetAllParamCustData(this ComPtr thisVtbl, uint indexFunc, uint indexParam, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllParamCustData(indexFunc, indexParam, ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static int GetAllVarCustData(this ComPtr thisVtbl, uint index, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllVarCustData(index, ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static int GetAllImplTypeCustData(this ComPtr thisVtbl, uint index, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllImplTypeCustData(index, ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfoVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..88cf93d6d3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeInfoVtblExtensions.gen.cs @@ -0,0 +1,2397 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeAttr(this ComPtr thisVtbl, TypeAttr** ppTypeAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttr); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeAttr(this ComPtr thisVtbl, ref TypeAttr* ppTypeAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeAttr** ppTypeAttrPtr = &ppTypeAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppTypeAttrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTComp); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFuncDesc(this ComPtr thisVtbl, uint index, FuncDesc** ppFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDesc); + return ret; + } + + /// To be documented. + public static unsafe int GetFuncDesc(this ComPtr thisVtbl, uint index, ref FuncDesc* ppFuncDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (FuncDesc** ppFuncDescPtr = &ppFuncDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, ppFuncDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVarDesc(this ComPtr thisVtbl, uint index, VarDesc** ppVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDesc); + return ret; + } + + /// To be documented. + public static unsafe int GetVarDesc(this ComPtr thisVtbl, uint index, ref VarDesc* ppVarDesc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (VarDesc** ppVarDescPtr = &ppVarDesc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, index, ppVarDescPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNames); + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNames, cMaxNames, pcNamesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNames); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgBstrNamesPtr = &rgBstrNames) + { + fixed (uint* pcNamesPtr = &pcNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, memid, rgBstrNamesPtr, cMaxNames, pcNamesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, uint* pRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefType); + return ret; + } + + /// To be documented. + public static int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, ref uint pRefType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRefTypePtr = &pRefType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, index, pRefTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetImplTypeFlags(this ComPtr thisVtbl, uint index, int* pImplTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlags); + return ret; + } + + /// To be documented. + public static int GetImplTypeFlags(this ComPtr thisVtbl, uint index, ref int pImplTypeFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pImplTypeFlagsPtr = &pImplTypeFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pImplTypeFlagsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemId); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNames, cNames, pMemIdPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemId); + } + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** rgszNamesPtr = &rgszNames) + { + fixed (int* pMemIdPtr = &pMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, rgszNamesPtr, cNames, pMemIdPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstance, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErrPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParams, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfo, puArgErrPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResult, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfo, puArgErrPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvInstancePtr = &pvInstance) + { + fixed (DispatchParams* pDispParamsPtr = &pDispParams) + { + fixed (Variant* pVarResultPtr = &pVarResult) + { + fixed (ExceptionInfo* pExcepInfoPtr = &pExcepInfo) + { + fixed (uint* puArgErrPtr = &puArgErr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pvInstancePtr, memid, wFlags, pDispParamsPtr, pVarResultPtr, pExcepInfoPtr, puArgErrPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, memid, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrName, pwOrdinalPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinal); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllName, pBstrNamePtr, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinal); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrName, pwOrdinalPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinal); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDllNamePtr = &pBstrDllName) + { + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (ushort* pwOrdinalPtr = &pwOrdinal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, memid, invKind, pBstrDllNamePtr, pBstrNamePtr, pwOrdinalPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ITypeInfo** ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ref ITypeInfo* ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, hRefType, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddressOfMember(this ComPtr thisVtbl, int memid, InvokeKind invKind, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppv); + return ret; + } + + /// To be documented. + public static unsafe int AddressOfMember(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, memid, invKind, ppvPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObj); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuter, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pUnkOuterPtr = &pUnkOuter) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pUnkOuterPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMops(this ComPtr thisVtbl, int memid, char** pBstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMops); + return ret; + } + + /// To be documented. + public static unsafe int GetMops(this ComPtr thisVtbl, int memid, ref char* pBstrMops) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrMopsPtr = &pBstrMops) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, memid, pBstrMopsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, uint* pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndex); + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, ref uint pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLib, pIndexPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, uint* pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndex); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, ref uint pIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeLib** ppTLibPtr = &ppTLib) + { + fixed (uint* pIndexPtr = &pIndex) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, ppTLibPtr, pIndexPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe void ReleaseTypeAttr(this ComPtr thisVtbl, TypeAttr* pTypeAttr) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttr); + } + + /// To be documented. + public static void ReleaseTypeAttr(this ComPtr thisVtbl, ref TypeAttr pTypeAttr) + { + var @this = thisVtbl.Handle; + fixed (TypeAttr* pTypeAttrPtr = &pTypeAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pTypeAttrPtr); + } + } + + /// To be documented. + public static unsafe void ReleaseFuncDesc(this ComPtr thisVtbl, FuncDesc* pFuncDesc) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDesc); + } + + /// To be documented. + public static void ReleaseFuncDesc(this ComPtr thisVtbl, ref FuncDesc pFuncDesc) + { + var @this = thisVtbl.Handle; + fixed (FuncDesc* pFuncDescPtr = &pFuncDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pFuncDescPtr); + } + } + + /// To be documented. + public static unsafe void ReleaseVarDesc(this ComPtr thisVtbl, VarDesc* pVarDesc) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDesc); + } + + /// To be documented. + public static void ReleaseVarDesc(this ComPtr thisVtbl, ref VarDesc pVarDesc) + { + var @this = thisVtbl.Handle; + fixed (VarDesc* pVarDescPtr = &pVarDesc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pVarDescPtr); + } + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetTypeComp(this ComPtr thisVtbl, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static int GetNames(this ComPtr thisVtbl, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNames(memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetNames(this ComPtr thisVtbl, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNames(memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + public static int GetRefTypeOfImplType(this ComPtr thisVtbl, uint index, Span pRefType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetRefTypeOfImplType(index, ref pRefType.GetPinnableReference()); + } + + /// To be documented. + public static int GetImplTypeFlags(this ComPtr thisVtbl, uint index, Span pImplTypeFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetImplTypeFlags(index, ref pImplTypeFlags.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, string[] rgszNamesSa, uint cNames, int* pMemId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static int GetIDsOfNames(this ComPtr thisVtbl, string[] rgszNamesSa, uint cNames, ref int pMemId) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = @this->GetIDsOfNames(rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, char** rgszNames, uint cNames, Span pMemId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetIDsOfNames(this ComPtr thisVtbl, ref char* rgszNames, uint cNames, Span pMemId) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetIDsOfNames(ref rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + public static int Invoke(this ComPtr thisVtbl, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Invoke(ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDllEntry(this ComPtr thisVtbl, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDllEntry(memid, invKind, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + public static int GetRefTypeInfo(this ComPtr thisVtbl, uint hRefType, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetRefTypeInfo(hRefType, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(pUnkOuter, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(pUnkOuter, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->CreateInstance(ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, Span pUnkOuter, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateInstance(ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static int GetMops(this ComPtr thisVtbl, int memid, string[] pBstrMopsSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrMops = (char**) SilkMarshal.StringArrayToPtr(pBstrMopsSa); + var ret = @this->GetMops(memid, pBstrMops); + SilkMarshal.CopyPtrToStringArray((nint) pBstrMops, pBstrMopsSa); + SilkMarshal.Free((nint) pBstrMops); + return ret; + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ITypeLib** ppTLib, Span pIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainingTypeLib(ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + public static int GetContainingTypeLib(this ComPtr thisVtbl, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetContainingTypeLib((ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + public static unsafe int GetContainingTypeLib(this ComPtr thisVtbl, ref ITypeLib* ppTLib, Span pIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainingTypeLib(ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseTypeAttr(this ComPtr thisVtbl, Span pTypeAttr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseTypeAttr(ref pTypeAttr.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseFuncDesc(this ComPtr thisVtbl, Span pFuncDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseFuncDesc(ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseVarDesc(this ComPtr thisVtbl, Span pVarDesc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseVarDesc(ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateInstance(this ComPtr thisVtbl, ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateInstance(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateInstance(ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLib2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLib2VtblExtensions.gen.cs new file mode 100644 index 0000000000..47eaca3e7f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLib2VtblExtensions.gen.cs @@ -0,0 +1,1971 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeLib2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static uint GetTypeInfoCount(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint index, ITypeInfo** ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint index, ref ITypeInfo* ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoType(this ComPtr thisVtbl, uint index, TypeKind* pTKind) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKind); + return ret; + } + + /// To be documented. + public static int GetTypeInfoType(this ComPtr thisVtbl, uint index, ref TypeKind pTKind) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeKind* pTKindPtr = &pTKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Guid* guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Guid* guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfo); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetLibAttr(this ComPtr thisVtbl, TLibAttr** ppTLibAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttr); + return ret; + } + + /// To be documented. + public static unsafe int GetLibAttr(this ComPtr thisVtbl, ref TLibAttr* ppTLibAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TLibAttr** ppTLibAttrPtr = &ppTLibAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTComp); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfName); + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + } + return ret; + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe void ReleaseTLibAttr(this ComPtr thisVtbl, TLibAttr* pTLibAttr) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttr); + } + + /// To be documented. + public static void ReleaseTLibAttr(this ComPtr thisVtbl, ref TLibAttr pTLibAttr) + { + var @this = thisVtbl.Handle; + fixed (TLibAttr* pTLibAttrPtr = &pTLibAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttrPtr); + } + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guid, pVarVal); + return ret; + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guid, pVarValPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, ref Guid guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guidPtr, pVarVal); + } + return ret; + } + + /// To be documented. + public static int GetCustData(this ComPtr thisVtbl, ref Guid guid, ref Variant pVarVal) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (Variant* pVarValPtr = &pVarVal) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, guidPtr, pVarValPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetLibStatistics(this ComPtr thisVtbl, uint* pcUniqueNames, uint* pcchUniqueNames) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNames, pcchUniqueNames); + return ret; + } + + /// To be documented. + public static unsafe int GetLibStatistics(this ComPtr thisVtbl, uint* pcUniqueNames, ref uint pcchUniqueNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchUniqueNamesPtr = &pcchUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNames, pcchUniqueNamesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLibStatistics(this ComPtr thisVtbl, ref uint pcUniqueNames, uint* pcchUniqueNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcUniqueNamesPtr = &pcUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNamesPtr, pcchUniqueNames); + } + return ret; + } + + /// To be documented. + public static int GetLibStatistics(this ComPtr thisVtbl, ref uint pcUniqueNames, ref uint pcchUniqueNames) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcUniqueNamesPtr = &pcUniqueNames) + { + fixed (uint* pcchUniqueNamesPtr = &pcchUniqueNames) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pcUniqueNamesPtr, pcchUniqueNamesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpString, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDll); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContext, pbstrHelpStringDllPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDll); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pbstrHelpStringPtr = &pbstrHelpString) + { + fixed (uint* pdwHelpStringContextPtr = &pdwHelpStringContext) + { + fixed (char** pbstrHelpStringDllPtr = &pbstrHelpStringDll) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, index, lcid, pbstrHelpStringPtr, pdwHelpStringContextPtr, pbstrHelpStringDllPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAllCustData(this ComPtr thisVtbl, CustomData* pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pCustData); + return ret; + } + + /// To be documented. + public static int GetAllCustData(this ComPtr thisVtbl, ref CustomData pCustData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (CustomData* pCustDataPtr = &pCustData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pCustDataPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetTypeInfo(this ComPtr thisVtbl, uint index, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfo(index, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public static int GetTypeInfoType(this ComPtr thisVtbl, uint index, Span pTKind) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoType(index, ref pTKind.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeInfoOfGuid(this ComPtr thisVtbl, out ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppTinfo = default; + return @this->GetTypeInfoOfGuid(SilkMarshal.GuidPtrOf(), (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Span guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoOfGuid(ref guid.GetPinnableReference(), ppTinfo); + } + + /// To be documented. + public static int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ref ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfoOfGuid(ref guid, (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Span guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoOfGuid(ref guid.GetPinnableReference(), ref ppTinfo); + } + + /// To be documented. + public static int GetTypeComp(this ComPtr thisVtbl, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(ref szNameBuf.GetPinnableReference(), lHashVal, pfName); + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseTLibAttr(this ComPtr thisVtbl, Span pTLibAttr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseTLibAttr(ref pTLibAttr.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Guid* guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(guid, ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCustData(this ComPtr thisVtbl, Span guid, Variant* pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(ref guid.GetPinnableReference(), pVarVal); + } + + /// To be documented. + public static int GetCustData(this ComPtr thisVtbl, Span guid, Span pVarVal) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCustData(ref guid.GetPinnableReference(), ref pVarVal.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLibStatistics(this ComPtr thisVtbl, uint* pcUniqueNames, Span pcchUniqueNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLibStatistics(pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLibStatistics(this ComPtr thisVtbl, Span pcUniqueNames, uint* pcchUniqueNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLibStatistics(ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + public static int GetLibStatistics(this ComPtr thisVtbl, Span pcUniqueNames, Span pcchUniqueNames) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLibStatistics(ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public static int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = @this->GetDocumentation2(index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + public static unsafe int GetDocumentation2(this ComPtr thisVtbl, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation2(index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + public static int GetAllCustData(this ComPtr thisVtbl, Span pCustData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAllCustData(ref pCustData.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr GetTypeInfoOfGuid(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetTypeInfoOfGuid(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationReaderVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationReaderVtblExtensions.gen.cs new file mode 100644 index 0000000000..f29f26d023 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationReaderVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeLibRegistrationReaderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int EnumTypeLibRegistrations(this ComPtr thisVtbl, IEnumUnknown** ppEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumUnknown); + return ret; + } + + /// To be documented. + public static unsafe int EnumTypeLibRegistrations(this ComPtr thisVtbl, ref IEnumUnknown* ppEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumUnknown** ppEnumUnknownPtr = &ppEnumUnknown) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ppEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int EnumTypeLibRegistrations(this ComPtr thisVtbl, ref ComPtr ppEnumUnknown) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumTypeLibRegistrations((IEnumUnknown**) ppEnumUnknown.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationVtblExtensions.gen.cs new file mode 100644 index 0000000000..74a4ffb5e7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibRegistrationVtblExtensions.gen.cs @@ -0,0 +1,373 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeLibRegistrationVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetGuid(this ComPtr thisVtbl, Guid* pGuid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGuid); + return ret; + } + + /// To be documented. + public static int GetGuid(this ComPtr thisVtbl, ref Guid pGuid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pGuidPtr = &pGuid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pGuidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, char** pVersion) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pVersion); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, ref char* pVersion) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pVersionPtr = &pVersion) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pVersionPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLcid(this ComPtr thisVtbl, uint* pLcid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pLcid); + return ret; + } + + /// To be documented. + public static int GetLcid(this ComPtr thisVtbl, ref uint pLcid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pLcidPtr = &pLcid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pLcidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWin32Path(this ComPtr thisVtbl, char** pWin32Path) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pWin32Path); + return ret; + } + + /// To be documented. + public static unsafe int GetWin32Path(this ComPtr thisVtbl, ref char* pWin32Path) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pWin32PathPtr = &pWin32Path) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pWin32PathPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWin64Path(this ComPtr thisVtbl, char** pWin64Path) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pWin64Path); + return ret; + } + + /// To be documented. + public static unsafe int GetWin64Path(this ComPtr thisVtbl, ref char* pWin64Path) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pWin64PathPtr = &pWin64Path) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pWin64PathPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, char** pDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref char* pDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pDisplayNamePtr = &pDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFlags(this ComPtr thisVtbl, uint* pFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pFlags); + return ret; + } + + /// To be documented. + public static int GetFlags(this ComPtr thisVtbl, ref uint pFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pFlagsPtr = &pFlags) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pFlagsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHelpDir(this ComPtr thisVtbl, char** pHelpDir) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pHelpDir); + return ret; + } + + /// To be documented. + public static unsafe int GetHelpDir(this ComPtr thisVtbl, ref char* pHelpDir) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pHelpDirPtr = &pHelpDir) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pHelpDirPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetGuid(this ComPtr thisVtbl, Span pGuid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGuid(ref pGuid.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, string[] pVersionSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pVersion = (char**) SilkMarshal.StringArrayToPtr(pVersionSa); + var ret = @this->GetVersion(pVersion); + SilkMarshal.CopyPtrToStringArray((nint) pVersion, pVersionSa); + SilkMarshal.Free((nint) pVersion); + return ret; + } + + /// To be documented. + public static int GetLcid(this ComPtr thisVtbl, Span pLcid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLcid(ref pLcid.GetPinnableReference()); + } + + /// To be documented. + public static int GetWin32Path(this ComPtr thisVtbl, string[] pWin32PathSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pWin32Path = (char**) SilkMarshal.StringArrayToPtr(pWin32PathSa); + var ret = @this->GetWin32Path(pWin32Path); + SilkMarshal.CopyPtrToStringArray((nint) pWin32Path, pWin32PathSa); + SilkMarshal.Free((nint) pWin32Path); + return ret; + } + + /// To be documented. + public static int GetWin64Path(this ComPtr thisVtbl, string[] pWin64PathSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pWin64Path = (char**) SilkMarshal.StringArrayToPtr(pWin64PathSa); + var ret = @this->GetWin64Path(pWin64Path); + SilkMarshal.CopyPtrToStringArray((nint) pWin64Path, pWin64PathSa); + SilkMarshal.Free((nint) pWin64Path); + return ret; + } + + /// To be documented. + public static int GetDisplayName(this ComPtr thisVtbl, string[] pDisplayNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pDisplayName = (char**) SilkMarshal.StringArrayToPtr(pDisplayNameSa); + var ret = @this->GetDisplayName(pDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) pDisplayName, pDisplayNameSa); + SilkMarshal.Free((nint) pDisplayName); + return ret; + } + + /// To be documented. + public static int GetFlags(this ComPtr thisVtbl, Span pFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFlags(ref pFlags.GetPinnableReference()); + } + + /// To be documented. + public static int GetHelpDir(this ComPtr thisVtbl, string[] pHelpDirSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pHelpDir = (char**) SilkMarshal.StringArrayToPtr(pHelpDirSa); + var ret = @this->GetHelpDir(pHelpDir); + SilkMarshal.CopyPtrToStringArray((nint) pHelpDir, pHelpDirSa); + SilkMarshal.Free((nint) pHelpDir); + return ret; + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibVtblExtensions.gen.cs new file mode 100644 index 0000000000..8731039039 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeLibVtblExtensions.gen.cs @@ -0,0 +1,1580 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeLibVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static uint GetTypeInfoCount(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint index, ITypeInfo** ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfo(this ComPtr thisVtbl, uint index, ref ITypeInfo* ppTInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, index, ppTInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoType(this ComPtr thisVtbl, uint index, TypeKind* pTKind) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKind); + return ret; + } + + /// To be documented. + public static int GetTypeInfoType(this ComPtr thisVtbl, uint index, ref TypeKind pTKind) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TypeKind* pTKindPtr = &pTKind) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, index, pTKindPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Guid* guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfo); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Guid* guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guid, ppTinfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfo); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidPtr = &guid) + { + fixed (ITypeInfo** ppTinfoPtr = &ppTinfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, guidPtr, ppTinfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetLibAttr(this ComPtr thisVtbl, TLibAttr** ppTLibAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttr); + return ret; + } + + /// To be documented. + public static unsafe int GetLibAttr(this ComPtr thisVtbl, ref TLibAttr* ppTLibAttr) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TLibAttr** ppTLibAttrPtr = &ppTLibAttr) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ppTLibAttrPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ITypeComp** ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTComp); + return ret; + } + + /// To be documented. + public static unsafe int GetTypeComp(this ComPtr thisVtbl, ref ITypeComp* ppTComp) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeComp** ppTCompPtr = &ppTComp) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppTCompPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrName, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContext, pBstrHelpFilePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocString, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFile); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContext, pBstrHelpFilePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFile); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** pBstrNamePtr = &pBstrName) + { + fixed (char** pBstrDocStringPtr = &pBstrDocString) + { + fixed (uint* pdwHelpContextPtr = &pdwHelpContext) + { + fixed (char** pBstrHelpFilePtr = &pBstrHelpFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, index, pBstrNamePtr, pBstrDocStringPtr, pdwHelpContextPtr, pBstrHelpFilePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfName); + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBuf, lHashVal, pfNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + } + return ret; + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfName); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* pfNamePtr = &pfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, szNameBufPtr, lHashVal, pfNamePtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBuf, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* szNameBufPtr = &szNameBuf) + { + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFound); + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemId, pcFoundPtr); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfo, rgMemIdPtr, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFound); + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemId, pcFoundPtr); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFound); + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) + { + var @this = thisVtbl.Handle; + int ret = default; + var szNameBufPtr = (byte*) SilkMarshal.StringToPtr(szNameBuf, NativeStringEncoding.UTF8); + fixed (ITypeInfo** ppTInfoPtr = &ppTInfo) + { + fixed (int* rgMemIdPtr = &rgMemId) + { + fixed (ushort* pcFoundPtr = &pcFound) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, szNameBufPtr, lHashVal, ppTInfoPtr, rgMemIdPtr, pcFoundPtr); + } + } + } + SilkMarshal.Free((nint)szNameBufPtr); + return ret; + } + + /// To be documented. + public static unsafe void ReleaseTLibAttr(this ComPtr thisVtbl, TLibAttr* pTLibAttr) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttr); + } + + /// To be documented. + public static void ReleaseTLibAttr(this ComPtr thisVtbl, ref TLibAttr pTLibAttr) + { + var @this = thisVtbl.Handle; + fixed (TLibAttr* pTLibAttrPtr = &pTLibAttr) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pTLibAttrPtr); + } + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetTypeInfo(this ComPtr thisVtbl, uint index, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfo(index, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + public static int GetTypeInfoType(this ComPtr thisVtbl, uint index, Span pTKind) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoType(index, ref pTKind.GetPinnableReference()); + } + + /// To be documented. + public static int GetTypeInfoOfGuid(this ComPtr thisVtbl, out ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppTinfo = default; + return @this->GetTypeInfoOfGuid(SilkMarshal.GuidPtrOf(), (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Span guid, ITypeInfo** ppTinfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoOfGuid(ref guid.GetPinnableReference(), ppTinfo); + } + + /// To be documented. + public static int GetTypeInfoOfGuid(this ComPtr thisVtbl, ref Guid guid, ref ComPtr ppTinfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeInfoOfGuid(ref guid, (ITypeInfo**) ppTinfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetTypeInfoOfGuid(this ComPtr thisVtbl, Span guid, ref ITypeInfo* ppTinfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTypeInfoOfGuid(ref guid.GetPinnableReference(), ref ppTinfo); + } + + /// To be documented. + public static int GetTypeComp(this ComPtr thisVtbl, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTypeComp((ITypeComp**) ppTComp.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + public static unsafe int GetDocumentation(this ComPtr thisVtbl, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDocumentation(index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int IsName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, int* pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(ref szNameBuf.GetPinnableReference(), lHashVal, pfName); + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static int IsName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsName(szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static int FindName(this ComPtr thisVtbl, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->FindName(szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + public static unsafe int FindName(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FindName(szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + public static void ReleaseTLibAttr(this ComPtr thisVtbl, Span pTLibAttr) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->ReleaseTLibAttr(ref pTLibAttr.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr GetTypeInfoOfGuid(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetTypeInfoOfGuid(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeMarshalVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeMarshalVtblExtensions.gen.cs new file mode 100644 index 0000000000..c63df11bae --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TypeMarshalVtblExtensions.gen.cs @@ -0,0 +1,1098 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TypeMarshalVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint* pSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContext, pSize); + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, ref uint pSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContext, pSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContextPtr, pSize); + } + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, ref uint pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvType, dwDestContext, pvDestContextPtr, pSizePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContext, pSize); + } + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, ref uint pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContext, pSizePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint* pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, pSize); + } + } + return ret; + } + + /// To be documented. + public static int Size(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, ref uint pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pSizePtr = &pSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, pSizePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWritten); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, ref T0 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvType, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContext, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, byte* pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBuffer, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, ref byte pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + } + } + } + return ret; + } + + /// To be documented. + public static int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, ref byte pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWritten); + SilkMarshal.Free((nint)pBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int Marshal(this ComPtr thisVtbl, ref T0 pvType, uint dwDestContext, ref T1 pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (void* pvDestContextPtr = &pvDestContext) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pvTypePtr, dwDestContext, pvDestContextPtr, cbBufferLength, pBufferPtr, pcbWrittenPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, uint* pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBuffer, pcbRead); + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, ref uint pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBuffer, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, uint* pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, ref uint pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvType, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBuffer, pcbRead); + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBuffer, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + } + } + return ret; + } + + /// To be documented. + public static int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, ref byte pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + fixed (byte* pBufferPtr = &pBuffer) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbRead); + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static int Unmarshal(this ComPtr thisVtbl, ref T0 pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, ref uint pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + var pBufferPtr = (byte*) SilkMarshal.StringToPtr(pBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pvTypePtr, dwFlags, cbBufferLength, pBufferPtr, pcbReadPtr); + } + SilkMarshal.Free((nint)pBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Free(this ComPtr thisVtbl, void* pvType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pvType); + return ret; + } + + /// To be documented. + public static int Free(this ComPtr thisVtbl, ref T0 pvType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvTypePtr = &pvType) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pvTypePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, Span pSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(pvType, dwDestContext, pvDestContext, ref pSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), pSize); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, Span pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), ref pSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint* pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, pSize); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, Span pSize) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, ref pSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Size(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint* pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), pSize); + } + + /// To be documented. + public static int Size(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, Span pSize) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Size(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), ref pSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, Span pBuffer, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, pvDestContext, cbBufferLength, ref pBuffer.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, Span pBuffer, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, pvDestContext, cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, pvDestContext, cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, byte* pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, Span pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, ref pBuffer.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, Span pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, void* pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(pvType, dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, byte* pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, Span pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, ref pBuffer.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, Span pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, void* pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, pvDestContext, cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, byte* pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, byte* pBuffer, Span pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, Span pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, ref pBuffer.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, Span pBuffer, Span pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, pcbWritten); + } + + /// To be documented. + public static int Marshal(this ComPtr thisVtbl, Span pvType, uint dwDestContext, Span pvDestContext, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbWritten) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Marshal(ref pvType.GetPinnableReference(), dwDestContext, ref pvDestContext.GetPinnableReference(), cbBufferLength, pBuffer, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, Span pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(pvType, dwFlags, cbBufferLength, pBuffer, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, Span pBuffer, uint* pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(pvType, dwFlags, cbBufferLength, ref pBuffer.GetPinnableReference(), pcbRead); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, Span pBuffer, Span pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(pvType, dwFlags, cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, void* pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(pvType, dwFlags, cbBufferLength, pBuffer, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, pBuffer, pcbRead); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, byte* pBuffer, Span pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, pBuffer, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, Span pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, ref pBuffer.GetPinnableReference(), pcbRead); + } + + /// To be documented. + public static int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, Span pBuffer, Span pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, ref pBuffer.GetPinnableReference(), ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, pBuffer, pcbRead); + } + + /// To be documented. + public static int Unmarshal(this ComPtr thisVtbl, Span pvType, uint dwFlags, uint cbBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pBuffer, Span pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Unmarshal(ref pvType.GetPinnableReference(), dwFlags, cbBufferLength, pBuffer, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static int Free(this ComPtr thisVtbl, Span pvType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Free(ref pvType.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDesc.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDesc.gen.cs new file mode 100644 index 0000000000..65f6781887 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDesc.gen.cs @@ -0,0 +1,135 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagVARDESC")] + public unsafe partial struct VarDesc + { + public VarDesc + ( + int? memid = null, + char* lpstrSchema = null, + VarDescUnion? anonymous = null, + ElemDesc? elemdescVar = null, + ushort? wVarFlags = null, + VarKind? varkind = null, + uint? oInst = null, + Variant* lpvarValue = null + ) : this() + { + if (memid is not null) + { + Memid = memid.Value; + } + + if (lpstrSchema is not null) + { + LpstrSchema = lpstrSchema; + } + + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (elemdescVar is not null) + { + ElemdescVar = elemdescVar.Value; + } + + if (wVarFlags is not null) + { + WVarFlags = wVarFlags.Value; + } + + if (varkind is not null) + { + Varkind = varkind.Value; + } + + if (oInst is not null) + { + OInst = oInst.Value; + } + + if (lpvarValue is not null) + { + LpvarValue = lpvarValue; + } + } + + + [NativeName("Type", "MEMBERID")] + [NativeName("Type.Name", "MEMBERID")] + [NativeName("Name", "memid")] + public int Memid; + + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "lpstrSchema")] + public char* LpstrSchema; + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_oaidl_L880_C36")] + [NativeName("Name", "anonymous1")] + public VarDescUnion Anonymous; + + [NativeName("Type", "ELEMDESC")] + [NativeName("Type.Name", "ELEMDESC")] + [NativeName("Name", "elemdescVar")] + public ElemDesc ElemdescVar; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wVarFlags")] + public ushort WVarFlags; + + [NativeName("Type", "VARKIND")] + [NativeName("Type.Name", "VARKIND")] + [NativeName("Name", "varkind")] + public VarKind Varkind; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref uint OInst + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].OInst; + } +#else + public uint OInst + { + get => Anonymous.OInst; + set => Anonymous.OInst = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Variant* LpvarValue + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].LpvarValue; + } +#else + public Variant* LpvarValue + { + get => Anonymous.LpvarValue; + set => Anonymous.LpvarValue = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDescUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDescUnion.gen.cs new file mode 100644 index 0000000000..98c9a8f72b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/VarDescUnion.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit)] + [NativeName("Name", "__AnonymousRecord_oaidl_L880_C36")] + public unsafe partial struct VarDescUnion + { + public VarDescUnion + ( + uint? oInst = null, + Variant* lpvarValue = null + ) : this() + { + if (oInst is not null) + { + OInst = oInst.Value; + } + + if (lpvarValue is not null) + { + LpvarValue = lpvarValue; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "oInst")] + public uint OInst; + + [FieldOffset(0)] + [NativeName("Type", "VARIANT *")] + [NativeName("Type.Name", "VARIANT *")] + [NativeName("Name", "lpvarValue")] + public Variant* LpvarValue; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/VersionedStream.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/VersionedStream.gen.cs new file mode 100644 index 0000000000..03bc2d54ce --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/VersionedStream.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagVersionedStream")] + public unsafe partial struct VersionedStream + { + public VersionedStream + ( + Guid? guidVersion = null, + Silk.NET.Core.Win32Extras.IStream* pStream = null + ) : this() + { + if (guidVersion is not null) + { + GuidVersion = guidVersion.Value; + } + + if (pStream is not null) + { + PStream = pStream; + } + } + + + [NativeName("Type", "GUID")] + [NativeName("Type.Name", "GUID")] + [NativeName("Name", "guidVersion")] + public Guid GuidVersion; + + [NativeName("Type", "IStream *")] + [NativeName("Type.Name", "IStream *")] + [NativeName("Name", "pStream")] + public Silk.NET.Core.Win32Extras.IStream* PStream; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs index bb58648af6..c32dba3c33 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs @@ -4682,6 +4682,9 @@ public unsafe partial class Windows : NativeAPI [NativeName("Name", "IO_REPARSE_TAG_RESERVED_RANGE")] public const int IOReparseTagReservedRange = unchecked((int) 0x2); [NativeName("Type", "unsigned long")] + [NativeName("Name", "IO_REPARSE_TAG_RESERVED_INVALID")] + public const uint IOReparseTagReservedInvalid = unchecked((uint) 0xFFFFFFFFC0008000); + [NativeName("Type", "unsigned long")] [NativeName("Name", "IO_REPARSE_TAG_MOUNT_POINT")] public const uint IOReparseTagMountPoint = unchecked((uint) 0xFFFFFFFFA0000003); [NativeName("Type", "unsigned long")] @@ -9056,6 +9059,12 @@ public unsafe partial class Windows : NativeAPI [NativeName("Name", "RPC_C_OPT_PRIVATE_BREAK_ON_SUSPEND")] public const int RpcCOptPrivateBreakOnSuspend = unchecked((int) 0x3); [NativeName("Type", "int")] + [NativeName("Name", "__REQUIRED_RPCNDR_H_VERSION__")] + public const int RequiredRpcndrHVersion = unchecked((int) 0x1F5); + [NativeName("Type", "int")] + [NativeName("Name", "__REQUIRED_RPCSAL_H_VERSION__")] + public const int RequiredRpcsalHVersion = unchecked((int) 0x64); + [NativeName("Type", "int")] [NativeName("Name", "ROTREGFLAGS_ALLOWANYCLIENT")] public const int RotregflagsAllowanyclient = unchecked((int) 0x1); [NativeName("Type", "int")] @@ -9122,6 +9131,324 @@ public unsafe partial class Windows : NativeAPI [NativeName("Name", "DCOMSCM_PING_DISALLOW_UNSECURE_CALL")] public const int DcomscmPingDisallowUnsecureCall = unchecked((int) 0x20); [NativeName("Type", "int")] + [NativeName("Name", "ROTFLAGS_REGISTRATIONKEEPSALIVE")] + public const int RotflagsRegistrationkeepsalive = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "ROTFLAGS_ALLOWANYCLIENT")] + public const int RotflagsAllowanyclient = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "ROT_COMPARE_MAX")] + public const int RotCompareMax = unchecked((int) 0x800); + [NativeName("Type", "int")] + [NativeName("Name", "WDT_INPROC_CALL")] + public const int WdtInprocCall = unchecked((int) 0x48746457); + [NativeName("Type", "int")] + [NativeName("Name", "WDT_REMOTE_CALL")] + public const int WdtRemoteCall = unchecked((int) 0x52746457); + [NativeName("Type", "int")] + [NativeName("Name", "WDT_INPROC64_CALL")] + public const int WdtInproc64Call = unchecked((int) 0x50746457); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_AUTO")] + public const int FadfAuto = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_STATIC")] + public const int FadfStatic = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_EMBEDDED")] + public const int FadfEmbedded = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_FIXEDSIZE")] + public const int FadfFixedsize = unchecked((int) 0x10); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_RECORD")] + public const int FadfRecord = unchecked((int) 0x20); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_HAVEIID")] + public const int FadfHaveiid = unchecked((int) 0x40); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_HAVEVARTYPE")] + public const int FadfHavevartype = unchecked((int) 0x80); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_BSTR")] + public const int FadfBstr = unchecked((int) 0x100); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_UNKNOWN")] + public const int FadfUnknown = unchecked((int) 0x200); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_DISPATCH")] + public const int FadfDispatch = unchecked((int) 0x400); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_VARIANT")] + public const int FadfVariant = unchecked((int) 0x800); + [NativeName("Type", "int")] + [NativeName("Name", "FADF_RESERVED")] + public const int FadfReserved = unchecked((int) 0xF008); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_NONE")] + public const int ParamflagNone = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FIN")] + public const int ParamflagFin = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FOUT")] + public const int ParamflagFout = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FLCID")] + public const int ParamflagFlcid = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FRETVAL")] + public const int ParamflagFretval = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FOPT")] + public const int ParamflagFopt = unchecked((int) 0x10); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FHASDEFAULT")] + public const int ParamflagFhasdefault = unchecked((int) 0x20); + [NativeName("Type", "int")] + [NativeName("Name", "PARAMFLAG_FHASCUSTDATA")] + public const int ParamflagFhascustdata = unchecked((int) 0x40); + [NativeName("Type", "int")] + [NativeName("Name", "IDLFLAG_NONE")] + public const int IdlflagNone = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "IDLFLAG_FIN")] + public const int IdlflagFin = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "IDLFLAG_FOUT")] + public const int IdlflagFout = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "IDLFLAG_FLCID")] + public const int IdlflagFlcid = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "IDLFLAG_FRETVAL")] + public const int IdlflagFretval = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "IMPLTYPEFLAG_FDEFAULT")] + public const int ImpltypeflagFdefault = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "IMPLTYPEFLAG_FSOURCE")] + public const int ImpltypeflagFsource = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "IMPLTYPEFLAG_FRESTRICTED")] + public const int ImpltypeflagFrestricted = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "IMPLTYPEFLAG_FDEFAULTVTABLE")] + public const int ImpltypeflagFdefaultvtable = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "DISPID_VALUE")] + public const int DispidValue = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSETFLAG_DEFAULT")] + public const int PropsetflagDefault = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSETFLAG_NONSIMPLE")] + public const int PropsetflagNonsimple = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSETFLAG_ANSI")] + public const int PropsetflagAnsi = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSETFLAG_UNBUFFERED")] + public const int PropsetflagUnbuffered = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSETFLAG_CASE_SENSITIVE")] + public const int PropsetflagCaseSensitive = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "PROPSET_BEHAVIOR_CASE_SENSITIVE")] + public const int PropsetBehaviorCaseSensitive = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "PID_DICTIONARY")] + public const int PidDictionary = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "PID_CODEPAGE")] + public const int PidCodepage = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "PID_FIRST_USABLE")] + public const int PidFirstUsable = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "PID_FIRST_NAME_DEFAULT")] + public const int PidFirstNameDefault = unchecked((int) 0xFFF); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_LOCALE")] + public const uint PidLocale = unchecked((uint) 0xFFFFFFFF80000000); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_MODIFY_TIME")] + public const uint PidModifyTime = unchecked((uint) 0xFFFFFFFF80000001); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_SECURITY")] + public const uint PidSecurity = unchecked((uint) 0xFFFFFFFF80000002); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_BEHAVIOR")] + public const uint PidBehavior = unchecked((uint) 0xFFFFFFFF80000003); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_ILLEGAL")] + public const uint PidIllegal = unchecked((uint) 0xFFFFFFFFFFFFFFFF); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_MIN_READONLY")] + public const uint PidMinReadonly = unchecked((uint) 0xFFFFFFFF80000000); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PID_MAX_READONLY")] + public const uint PidMaxReadonly = unchecked((uint) 0xFFFFFFFFBFFFFFFF); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PRSPEC_INVALID")] + public const uint PrspecInvalid = unchecked((uint) 0xFFFFFFFFFFFFFFFF); + [NativeName("Type", "int")] + [NativeName("Name", "PRSPEC_LPWSTR")] + public const int PrspecLpwstr = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "PRSPEC_PROPID")] + public const int PrspecPropid = unchecked((int) 0x1); + [NativeName("Type", "unsigned int")] + [NativeName("Name", "PROPSETHDR_OSVERSION_UNKNOWN")] + public const uint PropsethdrOsversionUnknown = unchecked((uint) 0xFFFFFFFFFFFFFFFF); + [NativeName("Type", "long")] + [NativeName("Name", "PIDDI_THUMBNAIL")] + public const int PiddiThumbnail = unchecked((int) 0x2); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_TITLE")] + public const int PidsiTitle = unchecked((int) 0x2); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_SUBJECT")] + public const int PidsiSubject = unchecked((int) 0x3); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_AUTHOR")] + public const int PidsiAuthor = unchecked((int) 0x4); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_KEYWORDS")] + public const int PidsiKeywords = unchecked((int) 0x5); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_COMMENTS")] + public const int PidsiComments = unchecked((int) 0x6); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_TEMPLATE")] + public const int PidsiTemplate = unchecked((int) 0x7); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_LASTAUTHOR")] + public const int PidsiLastauthor = unchecked((int) 0x8); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_REVNUMBER")] + public const int PidsiRevnumber = unchecked((int) 0x9); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_EDITTIME")] + public const int PidsiEdittime = unchecked((int) 0xA); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_LASTPRINTED")] + public const int PidsiLastprinted = unchecked((int) 0xB); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_CREATE_DTM")] + public const int PidsiCreateDtm = unchecked((int) 0xC); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_LASTSAVE_DTM")] + public const int PidsiLastsaveDtm = unchecked((int) 0xD); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_PAGECOUNT")] + public const int PidsiPagecount = unchecked((int) 0xE); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_WORDCOUNT")] + public const int PidsiWordcount = unchecked((int) 0xF); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_CHARCOUNT")] + public const int PidsiCharcount = unchecked((int) 0x10); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_THUMBNAIL")] + public const int PidsiThumbnail = unchecked((int) 0x11); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_APPNAME")] + public const int PidsiAppname = unchecked((int) 0x12); + [NativeName("Type", "long")] + [NativeName("Name", "PIDSI_DOC_SECURITY")] + public const int PidsiDocSecurity = unchecked((int) 0x13); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_CATEGORY")] + public const int PiddsiCategory = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_PRESFORMAT")] + public const int PiddsiPresformat = unchecked((int) 0x3); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_BYTECOUNT")] + public const int PiddsiBytecount = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_LINECOUNT")] + public const int PiddsiLinecount = unchecked((int) 0x5); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_PARCOUNT")] + public const int PiddsiParcount = unchecked((int) 0x6); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_SLIDECOUNT")] + public const int PiddsiSlidecount = unchecked((int) 0x7); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_NOTECOUNT")] + public const int PiddsiNotecount = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_HIDDENCOUNT")] + public const int PiddsiHiddencount = unchecked((int) 0x9); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_MMCLIPCOUNT")] + public const int PiddsiMmclipcount = unchecked((int) 0xA); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_SCALE")] + public const int PiddsiScale = unchecked((int) 0xB); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_HEADINGPAIR")] + public const int PiddsiHeadingpair = unchecked((int) 0xC); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_DOCPARTS")] + public const int PiddsiDocparts = unchecked((int) 0xD); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_MANAGER")] + public const int PiddsiManager = unchecked((int) 0xE); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_COMPANY")] + public const int PiddsiCompany = unchecked((int) 0xF); + [NativeName("Type", "int")] + [NativeName("Name", "PIDDSI_LINKSDIRTY")] + public const int PiddsiLinksdirty = unchecked((int) 0x10); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_EDITOR")] + public const int PidmsiEditor = unchecked((int) 0x2); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_SUPPLIER")] + public const int PidmsiSupplier = unchecked((int) 0x3); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_SOURCE")] + public const int PidmsiSource = unchecked((int) 0x4); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_SEQUENCE_NO")] + public const int PidmsiSequenceNo = unchecked((int) 0x5); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_PROJECT")] + public const int PidmsiProject = unchecked((int) 0x6); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_STATUS")] + public const int PidmsiStatus = unchecked((int) 0x7); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_OWNER")] + public const int PidmsiOwner = unchecked((int) 0x8); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_RATING")] + public const int PidmsiRating = unchecked((int) 0x9); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_PRODUCTION")] + public const int PidmsiProduction = unchecked((int) 0xA); + [NativeName("Type", "long")] + [NativeName("Name", "PIDMSI_COPYRIGHT")] + public const int PidmsiCopyright = unchecked((int) 0xB); + [NativeName("Type", "int")] + [NativeName("Name", "MULTICLASSINFO_GETTYPEINFO")] + public const int MulticlassinfoGettypeinfo = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "MULTICLASSINFO_GETNUMRESERVEDDISPIDS")] + public const int MulticlassinfoGetnumreserveddispids = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "MULTICLASSINFO_GETIIDPRIMARY")] + public const int MulticlassinfoGetiidprimary = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "MULTICLASSINFO_GETIIDSOURCE")] + public const int MulticlassinfoGetiidsource = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "TIFLAGS_EXTENDDISPATCHONLY")] + public const int TiflagsExtenddispatchonly = unchecked((int) 0x1); + [NativeName("Type", "int")] [NativeName("Name", "EVENT_MIN_LEVEL")] public const int EventMinLevel = unchecked((int) 0x0); [NativeName("Type", "int")] @@ -30485,13144 +30812,61232 @@ public unsafe partial class Windows : NativeAPI public partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 555, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventUnregister")] - public partial uint EventUnregister(ulong RegHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 568, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventSetInformation")] - public unsafe partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, void* EventInformation, uint InformationLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 568, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventSetInformation")] - public partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, ref T0 EventInformation, uint InformationLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 611, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventEnabled")] - public unsafe partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 611, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventEnabled")] - public partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 652, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventProviderEnabled")] - public partial byte EventProviderEnabled(ulong RegHandle, byte Level, ulong Keyword); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public unsafe partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* String); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char String); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string String); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 781, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventActivityIdControl")] - public unsafe partial uint EventActivityIdControl(uint ControlCode, Guid* ActivityId); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 781, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventActivityIdControl")] - public partial uint EventActivityIdControl(uint ControlCode, ref Guid ActivityId); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTrace")] - public unsafe partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, ulong TraceHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTrace")] - public partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, ulong TraceHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceSetInformation")] - public unsafe partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceSetInformation")] - public partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, uint* ReturnLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, ref uint ReturnLength); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(void* RegHandle, EventInstanceInfo* InstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(void* RegHandle, ref EventInstanceInfo InstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(ref T0 RegHandle, EventInstanceInfo* InstInfo) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public partial uint CreateTraceInstanceId(ref T0 RegHandle, ref EventInstanceInfo InstInfo) where T0 : unmanaged; + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEvent")] - public unsafe partial uint TraceEvent(ulong TraceHandle, EventTraceHeader* EventTrace); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEvent")] - public partial uint TraceEvent(ulong TraceHandle, ref EventTraceHeader EventTrace); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public unsafe partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Proxy")] + public partial int IDispatchRemoteInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public unsafe partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_RemoteInvoke_Stub")] + public partial void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(IEnumVARIANT* This, uint celt, Variant* rgVar, uint* pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(IEnumVARIANT* This, uint celt, Variant* rgVar, ref uint pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(IEnumVARIANT* This, uint celt, ref Variant rgVar, uint* pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(IEnumVARIANT* This, uint celt, ref Variant rgVar, ref uint pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(ref IEnumVARIANT This, uint celt, Variant* rgVar, uint* pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(ref IEnumVARIANT This, uint celt, Variant* rgVar, ref uint pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public unsafe partial int IEnumVARIANTRemoteNextProxy(ref IEnumVARIANT This, uint celt, ref Variant rgVar, uint* pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Proxy")] + public partial int IEnumVARIANTRemoteNextProxy(ref IEnumVARIANT This, uint celt, ref Variant rgVar, ref uint pCeltFetched); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public unsafe partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_RemoteNext_Stub")] + public partial void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Proxy")] + public unsafe partial int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public unsafe partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBind_Stub")] + public partial void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Proxy")] + public unsafe partial int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public unsafe partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_RemoteBindType_Stub")] + public partial void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ITypeInfo* This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ITypeInfo* This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ITypeInfo* This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ITypeInfo* This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ref ITypeInfo This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ref ITypeInfo This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ref ITypeInfo This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoRemoteGetTypeAttrProxy(ref ITypeInfo This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public unsafe partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetTypeAttr_Stub")] + public partial void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ref ITypeInfo This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ref ITypeInfo This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ref ITypeInfo This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetFuncDescProxy(ref ITypeInfo This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetFuncDesc_Stub")] + public partial void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ITypeInfo* This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ITypeInfo* This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ref ITypeInfo This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ref ITypeInfo This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ref ITypeInfo This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Proxy")] + public unsafe partial int ITypeInfoRemoteGetVarDescProxy(ref ITypeInfo This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public unsafe partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetVarDesc_Stub")] + public partial void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Proxy")] + public unsafe partial int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public unsafe partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetNames_Stub")] + public partial void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3205, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoLocalGetIDsOfNamesProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3205, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Proxy")] + public partial int ITypeInfoLocalGetIDsOfNamesProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public unsafe partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalGetIDsOfNames_Stub")] + public partial void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3216, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Proxy")] + public unsafe partial int ITypeInfoLocalInvokeProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3216, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Proxy")] + public partial int ITypeInfoLocalInvokeProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public unsafe partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalInvoke_Stub")] + public partial void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDocumentation_Stub")] + public partial void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Proxy")] + public unsafe partial int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public unsafe partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetDllEntry_Stub")] + public partial void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3261, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Proxy")] + public unsafe partial int ITypeInfoLocalAddressOfMemberProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3261, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Proxy")] + public partial int ITypeInfoLocalAddressOfMemberProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public unsafe partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalAddressOfMember_Stub")] + public partial void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ITypeInfo* This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ITypeInfo* This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ITypeInfo* This, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ITypeInfo* This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Proxy")] + public unsafe partial int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public unsafe partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteCreateInstance_Stub")] + public partial void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ITypeInfo* This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ITypeInfo* This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ITypeInfo* This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ITypeInfo* This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public unsafe partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_RemoteGetContainingTypeLib_Stub")] + public partial void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3298, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Proxy")] + public unsafe partial int ITypeInfoLocalReleaseTypeAttrProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3298, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Proxy")] + public partial int ITypeInfoLocalReleaseTypeAttrProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public unsafe partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseTypeAttr_Stub")] + public partial void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3309, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Proxy")] + public unsafe partial int ITypeInfoLocalReleaseFuncDescProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3309, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Proxy")] + public partial int ITypeInfoLocalReleaseFuncDescProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseFuncDesc_Stub")] + public partial void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3320, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Proxy")] + public unsafe partial int ITypeInfoLocalReleaseVarDescProxy(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 3320, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Proxy")] + public partial int ITypeInfoLocalReleaseVarDescProxy(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public unsafe partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_LocalReleaseVarDesc_Stub")] + public partial void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_RemoteGetDocumentation2_Stub")] + public partial void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Proxy")] + public unsafe partial int ITypeLibRemoteGetTypeInfoCountProxy(ITypeLib* This, uint* pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Proxy")] + public unsafe partial int ITypeLibRemoteGetTypeInfoCountProxy(ITypeLib* This, ref uint pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Proxy")] + public unsafe partial int ITypeLibRemoteGetTypeInfoCountProxy(ref ITypeLib This, uint* pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Proxy")] + public partial int ITypeLibRemoteGetTypeInfoCountProxy(ref ITypeLib This, ref uint pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public unsafe partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetTypeInfoCount_Stub")] + public partial void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ITypeLib* This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ITypeLib* This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ITypeLib* This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ITypeLib* This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ref ITypeLib This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ref ITypeLib This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ref ITypeLib This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Proxy")] + public unsafe partial int ITypeLibRemoteGetLibAttrProxy(ref ITypeLib This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public unsafe partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetLibAttr_Stub")] + public partial void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Proxy")] + public unsafe partial int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public unsafe partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteGetDocumentation_Stub")] + public partial void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Proxy")] + public unsafe partial int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public unsafe partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteIsName_Stub")] + public partial void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Proxy")] + public unsafe partial int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public unsafe partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_RemoteFindName_Stub")] + public partial void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4162, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Proxy")] + public unsafe partial int ITypeLibLocalReleaseTLibAttrProxy(ITypeLib* This); + + /// To be documented. + [NativeName("Src", "Line 4162, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Proxy")] + public partial int ITypeLibLocalReleaseTLibAttrProxy(ref ITypeLib This); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public unsafe partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_LocalReleaseTLibAttr_Stub")] + public partial void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ITypeLib2* This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ITypeLib2* This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ITypeLib2* This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ITypeLib2* This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ref ITypeLib2 This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ref ITypeLib2 This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2RemoteGetLibStatisticsProxy(ref ITypeLib2 This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Proxy")] + public partial int ITypeLib2RemoteGetLibStatisticsProxy(ref ITypeLib2 This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public unsafe partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetLibStatistics_Stub")] + public partial void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public unsafe partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_RemoteGetDocumentation2_Stub")] + public partial void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public unsafe partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Proxy")] + public partial int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public unsafe partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_RemoteRead_Stub")] + public partial void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize")] + public unsafe partial uint BSTRUserSize(uint* arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize")] + public unsafe partial uint BSTRUserSize(uint* arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize")] + public unsafe partial uint BSTRUserSize(ref uint arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize")] + public unsafe partial uint BSTRUserSize(ref uint arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal")] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal")] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree")] + public unsafe partial void BSTRUserFree(uint* arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree")] + public unsafe partial void BSTRUserFree(uint* arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree")] + public unsafe partial void BSTRUserFree(ref uint arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree")] + public unsafe partial void BSTRUserFree(ref uint arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize(uint* arg0, uint arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize(uint* arg0, uint arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize(ref uint arg0, uint arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize")] + public partial uint CLEANLOCALSTORAGEUserSize(ref uint arg0, uint arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal")] + public partial string CLEANLOCALSTORAGEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal")] + public partial string CLEANLOCALSTORAGEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree")] + public unsafe partial void CLEANLOCALSTORAGEUserFree(uint* arg0, CleanLocalStorage* arg1); + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree")] + public unsafe partial void CLEANLOCALSTORAGEUserFree(uint* arg0, ref CleanLocalStorage arg1); + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree")] + public unsafe partial void CLEANLOCALSTORAGEUserFree(ref uint arg0, CleanLocalStorage* arg1); + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree")] + public partial void CLEANLOCALSTORAGEUserFree(ref uint arg0, ref CleanLocalStorage arg1); + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize")] + public unsafe partial uint VARIANTUserSize(uint* arg0, uint arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize")] + public unsafe partial uint VARIANTUserSize(uint* arg0, uint arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize")] + public unsafe partial uint VARIANTUserSize(ref uint arg0, uint arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize")] + public partial uint VARIANTUserSize(ref uint arg0, uint arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public partial string VARIANTUserMarshalS(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial string VARIANTUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public unsafe partial byte* VARIANTUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal")] + public partial string VARIANTUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public partial string VARIANTUserUnmarshalS(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial string VARIANTUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public unsafe partial byte* VARIANTUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal")] + public partial string VARIANTUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree")] + public unsafe partial void VARIANTUserFree(uint* arg0, Variant* arg1); + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree")] + public unsafe partial void VARIANTUserFree(uint* arg0, ref Variant arg1); + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree")] + public unsafe partial void VARIANTUserFree(ref uint arg0, Variant* arg1); + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree")] + public partial void VARIANTUserFree(ref uint arg0, ref Variant arg1); + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize64")] + public unsafe partial uint BSTRUserSize64(uint* arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize64")] + public unsafe partial uint BSTRUserSize64(uint* arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize64")] + public unsafe partial uint BSTRUserSize64(ref uint arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserSize64")] + public unsafe partial uint BSTRUserSize64(ref uint arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial byte* BSTRUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal64")] + public unsafe partial string BSTRUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial byte* BSTRUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal64")] + public unsafe partial string BSTRUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree64")] + public unsafe partial void BSTRUserFree64(uint* arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree64")] + public unsafe partial void BSTRUserFree64(uint* arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree64")] + public unsafe partial void BSTRUserFree64(ref uint arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "BSTR_UserFree64")] + public unsafe partial void BSTRUserFree64(ref uint arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize64")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize64(uint* arg0, uint arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize64")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize64(uint* arg0, uint arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize64")] + public unsafe partial uint CLEANLOCALSTORAGEUserSize64(ref uint arg0, uint arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserSize64")] + public partial uint CLEANLOCALSTORAGEUserSize64(ref uint arg0, uint arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserMarshal64")] + public partial string CLEANLOCALSTORAGEUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, byte* arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, byte* arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, ref byte arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, ref byte arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public unsafe partial byte* CLEANLOCALSTORAGEUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserUnmarshal64")] + public partial string CLEANLOCALSTORAGEUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref CleanLocalStorage arg2); + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree64")] + public unsafe partial void CLEANLOCALSTORAGEUserFree64(uint* arg0, CleanLocalStorage* arg1); + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree64")] + public unsafe partial void CLEANLOCALSTORAGEUserFree64(uint* arg0, ref CleanLocalStorage arg1); + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree64")] + public unsafe partial void CLEANLOCALSTORAGEUserFree64(ref uint arg0, CleanLocalStorage* arg1); + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "CLEANLOCALSTORAGE_UserFree64")] + public partial void CLEANLOCALSTORAGEUserFree64(ref uint arg0, ref CleanLocalStorage arg1); + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize64")] + public unsafe partial uint VARIANTUserSize64(uint* arg0, uint arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize64")] + public unsafe partial uint VARIANTUserSize64(uint* arg0, uint arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize64")] + public unsafe partial uint VARIANTUserSize64(ref uint arg0, uint arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserSize64")] + public partial uint VARIANTUserSize64(ref uint arg0, uint arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public partial string VARIANTUserMarshal64S(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial string VARIANTUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public unsafe partial byte* VARIANTUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserMarshal64")] + public partial string VARIANTUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(ref uint arg0, byte* arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(ref uint arg0, byte* arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(ref uint arg0, ref byte arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public partial string VARIANTUserUnmarshal64S(ref uint arg0, ref byte arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial string VARIANTUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public unsafe partial byte* VARIANTUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "VARIANT_UserUnmarshal64")] + public partial string VARIANTUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Variant arg2); + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree64")] + public unsafe partial void VARIANTUserFree64(uint* arg0, Variant* arg1); + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree64")] + public unsafe partial void VARIANTUserFree64(uint* arg0, ref Variant arg1); + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree64")] + public unsafe partial void VARIANTUserFree64(ref uint arg0, Variant* arg1); + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + [NativeApi(EntryPoint = "VARIANT_UserFree64")] + public partial void VARIANTUserFree64(ref uint arg0, ref Variant arg1); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public unsafe partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Proxy")] + public partial int IDispatchInvokeProxy(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(IDispatch* This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public unsafe partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IDispatch_Invoke_Stub")] + public partial int IDispatchInvokeStub(ref IDispatch This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(IEnumVARIANT* This, uint celt, Variant* rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(IEnumVARIANT* This, uint celt, Variant* rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(IEnumVARIANT* This, uint celt, ref Variant rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(IEnumVARIANT* This, uint celt, ref Variant rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(ref IEnumVARIANT This, uint celt, Variant* rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(ref IEnumVARIANT This, uint celt, Variant* rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public unsafe partial int IEnumVARIANTNextProxy(ref IEnumVARIANT This, uint celt, ref Variant rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Proxy")] + public partial int IEnumVARIANTNextProxy(ref IEnumVARIANT This, uint celt, ref Variant rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(IEnumVARIANT* This, uint celt, Variant* rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(IEnumVARIANT* This, uint celt, Variant* rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(IEnumVARIANT* This, uint celt, ref Variant rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(IEnumVARIANT* This, uint celt, ref Variant rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(ref IEnumVARIANT This, uint celt, Variant* rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(ref IEnumVARIANT This, uint celt, Variant* rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public unsafe partial int IEnumVARIANTNextStub(ref IEnumVARIANT This, uint celt, ref Variant rgVar, uint* pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IEnumVARIANT_Next_Stub")] + public partial int IEnumVARIANTNextStub(ref IEnumVARIANT This, uint celt, ref Variant rgVar, ref uint pCeltFetched); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Proxy")] + public unsafe partial int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_Bind_Stub")] + public unsafe partial int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Proxy")] + public unsafe partial int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, char* szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, char* szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, ref char szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeComp_BindType_Stub")] + public unsafe partial int ITypeCompBindTypeStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo); + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoGetTypeAttrProxy(ITypeInfo* This, TypeAttr** ppTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoGetTypeAttrProxy(ITypeInfo* This, ref TypeAttr* ppTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoGetTypeAttrProxy(ref ITypeInfo This, TypeAttr** ppTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Proxy")] + public unsafe partial int ITypeInfoGetTypeAttrProxy(ref ITypeInfo This, ref TypeAttr* ppTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ITypeInfo* This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ITypeInfo* This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ITypeInfo* This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ITypeInfo* This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ref ITypeInfo This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ref ITypeInfo This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ref ITypeInfo This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetTypeAttr_Stub")] + public unsafe partial int ITypeInfoGetTypeAttrStub(ref ITypeInfo This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoGetFuncDescProxy(ITypeInfo* This, uint index, FuncDesc** ppFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoGetFuncDescProxy(ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoGetFuncDescProxy(ref ITypeInfo This, uint index, FuncDesc** ppFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Proxy")] + public unsafe partial int ITypeInfoGetFuncDescProxy(ref ITypeInfo This, uint index, ref FuncDesc* ppFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ref ITypeInfo This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ref ITypeInfo This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ref ITypeInfo This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetFuncDesc_Stub")] + public unsafe partial int ITypeInfoGetFuncDescStub(ref ITypeInfo This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Proxy")] + public unsafe partial int ITypeInfoGetVarDescProxy(ITypeInfo* This, uint index, VarDesc** ppVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Proxy")] + public unsafe partial int ITypeInfoGetVarDescProxy(ITypeInfo* This, uint index, ref VarDesc* ppVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Proxy")] + public unsafe partial int ITypeInfoGetVarDescProxy(ref ITypeInfo This, uint index, VarDesc** ppVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Proxy")] + public unsafe partial int ITypeInfoGetVarDescProxy(ref ITypeInfo This, uint index, ref VarDesc* ppVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ITypeInfo* This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ITypeInfo* This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ref ITypeInfo This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ref ITypeInfo This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ref ITypeInfo This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetVarDesc_Stub")] + public unsafe partial int ITypeInfoGetVarDescStub(ref ITypeInfo This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Proxy")] + public unsafe partial int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames); + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetNames_Stub")] + public unsafe partial int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, char** rgszNames, uint cNames, int* pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, char** rgszNames, uint cNames, ref int pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, ref char* rgszNames, uint cNames, int* pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, ref char* rgszNames, uint cNames, ref int pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, char** rgszNames, uint cNames, int* pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, char** rgszNames, uint cNames, ref int pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, ref char* rgszNames, uint cNames, int* pMemId); + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Proxy")] + public unsafe partial int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, ref char* rgszNames, uint cNames, ref int pMemId); + + /// To be documented. + [NativeName("Src", "Line 6086, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Stub")] + public unsafe partial int ITypeInfoGetIDsOfNamesStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6086, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetIDsOfNames_Stub")] + public partial int ITypeInfoGetIDsOfNamesStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ITypeInfo* This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr); + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public unsafe partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Proxy")] + public partial int ITypeInfoInvokeProxy(ref ITypeInfo This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6100, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Stub")] + public unsafe partial int ITypeInfoInvokeStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6100, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_Invoke_Stub")] + public partial int ITypeInfoInvokeStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Proxy")] + public unsafe partial int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDocumentation_Stub")] + public unsafe partial int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Proxy")] + public unsafe partial int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetDllEntry_Stub")] + public unsafe partial int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal); + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Proxy")] + public unsafe partial int ITypeInfoAddressOfMemberProxy(ITypeInfo* This, int memid, InvokeKind invKind, void** ppv); + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Proxy")] + public unsafe partial int ITypeInfoAddressOfMemberProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref void* ppv); + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Proxy")] + public unsafe partial int ITypeInfoAddressOfMemberProxy(ref ITypeInfo This, int memid, InvokeKind invKind, void** ppv); + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Proxy")] + public unsafe partial int ITypeInfoAddressOfMemberProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref void* ppv); + + /// To be documented. + [NativeName("Src", "Line 6151, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Stub")] + public unsafe partial int ITypeInfoAddressOfMemberStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6151, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_AddressOfMember_Stub")] + public partial int ITypeInfoAddressOfMemberStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ITypeInfo* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Proxy")] + public unsafe partial int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ITypeInfo* This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ITypeInfo* This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ITypeInfo* This, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ITypeInfo* This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ref ITypeInfo This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ref ITypeInfo This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ref ITypeInfo This, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_CreateInstance_Stub")] + public unsafe partial int ITypeInfoCreateInstanceStub(ref ITypeInfo This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ITypeInfo* This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ITypeInfo* This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ITypeInfo* This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ITypeInfo* This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Proxy")] + public unsafe partial int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ITypeInfo* This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ITypeInfo* This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ITypeInfo* This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ITypeInfo* This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ITypeLib** ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ITypeLib** ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ref ITypeLib* ppTLib, uint* pIndex); + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_GetContainingTypeLib_Stub")] + public unsafe partial int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ref ITypeLib* ppTLib, ref uint pIndex); + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Proxy")] + public unsafe partial void ITypeInfoReleaseTypeAttrProxy(ITypeInfo* This, TypeAttr* pTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Proxy")] + public unsafe partial void ITypeInfoReleaseTypeAttrProxy(ITypeInfo* This, ref TypeAttr pTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Proxy")] + public unsafe partial void ITypeInfoReleaseTypeAttrProxy(ref ITypeInfo This, TypeAttr* pTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Proxy")] + public partial void ITypeInfoReleaseTypeAttrProxy(ref ITypeInfo This, ref TypeAttr pTypeAttr); + + /// To be documented. + [NativeName("Src", "Line 6182, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Stub")] + public unsafe partial int ITypeInfoReleaseTypeAttrStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6182, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseTypeAttr_Stub")] + public partial int ITypeInfoReleaseTypeAttrStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseFuncDescProxy(ITypeInfo* This, FuncDesc* pFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseFuncDescProxy(ITypeInfo* This, ref FuncDesc pFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseFuncDescProxy(ref ITypeInfo This, FuncDesc* pFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Proxy")] + public partial void ITypeInfoReleaseFuncDescProxy(ref ITypeInfo This, ref FuncDesc pFuncDesc); + + /// To be documented. + [NativeName("Src", "Line 6190, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Stub")] + public unsafe partial int ITypeInfoReleaseFuncDescStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6190, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseFuncDesc_Stub")] + public partial int ITypeInfoReleaseFuncDescStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseVarDescProxy(ITypeInfo* This, VarDesc* pVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseVarDescProxy(ITypeInfo* This, ref VarDesc pVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Proxy")] + public unsafe partial void ITypeInfoReleaseVarDescProxy(ref ITypeInfo This, VarDesc* pVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Proxy")] + public partial void ITypeInfoReleaseVarDescProxy(ref ITypeInfo This, ref VarDesc pVarDesc); + + /// To be documented. + [NativeName("Src", "Line 6198, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Stub")] + public unsafe partial int ITypeInfoReleaseVarDescStub(ITypeInfo* This); + + /// To be documented. + [NativeName("Src", "Line 6198, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo_ReleaseVarDesc_Stub")] + public partial int ITypeInfoReleaseVarDescStub(ref ITypeInfo This); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeInfo2_GetDocumentation2_Stub")] + public unsafe partial int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6221, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Proxy")] + public unsafe partial uint ITypeLibGetTypeInfoCountProxy(ITypeLib* This); + + /// To be documented. + [NativeName("Src", "Line 6221, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Proxy")] + public partial uint ITypeLibGetTypeInfoCountProxy(ref ITypeLib This); + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Stub")] + public unsafe partial int ITypeLibGetTypeInfoCountStub(ITypeLib* This, uint* pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Stub")] + public unsafe partial int ITypeLibGetTypeInfoCountStub(ITypeLib* This, ref uint pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Stub")] + public unsafe partial int ITypeLibGetTypeInfoCountStub(ref ITypeLib This, uint* pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetTypeInfoCount_Stub")] + public partial int ITypeLibGetTypeInfoCountStub(ref ITypeLib This, ref uint pcTInfo); + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Proxy")] + public unsafe partial int ITypeLibGetLibAttrProxy(ITypeLib* This, TLibAttr** ppTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Proxy")] + public unsafe partial int ITypeLibGetLibAttrProxy(ITypeLib* This, ref TLibAttr* ppTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Proxy")] + public unsafe partial int ITypeLibGetLibAttrProxy(ref ITypeLib This, TLibAttr** ppTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Proxy")] + public unsafe partial int ITypeLibGetLibAttrProxy(ref ITypeLib This, ref TLibAttr* ppTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ITypeLib* This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ITypeLib* This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ITypeLib* This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ITypeLib* This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ref ITypeLib This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ref ITypeLib This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ref ITypeLib This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy); + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetLibAttr_Stub")] + public unsafe partial int ITypeLibGetLibAttrStub(ref ITypeLib This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Proxy")] + public unsafe partial int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_GetDocumentation_Stub")] + public unsafe partial int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public partial int ITypeLibIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public unsafe partial int ITypeLibIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName); + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Proxy")] + public partial int ITypeLibIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_IsName_Stub")] + public unsafe partial int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound); + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Proxy")] + public unsafe partial int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_FindName_Stub")] + public unsafe partial int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName); + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Proxy")] + public unsafe partial void ITypeLibReleaseTLibAttrProxy(ITypeLib* This, TLibAttr* pTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Proxy")] + public unsafe partial void ITypeLibReleaseTLibAttrProxy(ITypeLib* This, ref TLibAttr pTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Proxy")] + public unsafe partial void ITypeLibReleaseTLibAttrProxy(ref ITypeLib This, TLibAttr* pTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Proxy")] + public partial void ITypeLibReleaseTLibAttrProxy(ref ITypeLib This, ref TLibAttr pTLibAttr); + + /// To be documented. + [NativeName("Src", "Line 6299, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Stub")] + public unsafe partial int ITypeLibReleaseTLibAttrStub(ITypeLib* This); + + /// To be documented. + [NativeName("Src", "Line 6299, Column 51 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib_ReleaseTLibAttr_Stub")] + public partial int ITypeLibReleaseTLibAttrStub(ref ITypeLib This); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ITypeLib2* This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ITypeLib2* This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ITypeLib2* This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ITypeLib2* This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ref ITypeLib2 This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ref ITypeLib2 This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public unsafe partial int ITypeLib2GetLibStatisticsProxy(ref ITypeLib2 This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Proxy")] + public partial int ITypeLib2GetLibStatisticsProxy(ref ITypeLib2 This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ITypeLib2* This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ITypeLib2* This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ITypeLib2* This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ITypeLib2* This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ref ITypeLib2 This, uint* pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ref ITypeLib2 This, uint* pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public unsafe partial int ITypeLib2GetLibStatisticsStub(ref ITypeLib2 This, ref uint pcUniqueNames, uint* pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetLibStatistics_Stub")] + public partial int ITypeLib2GetLibStatisticsStub(ref ITypeLib2 This, ref uint pcUniqueNames, ref uint pcchUniqueNames); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Proxy")] + public unsafe partial int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "ITypeLib2_GetDocumentation2_Stub")] + public unsafe partial int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public unsafe partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Proxy")] + public partial int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, IErrorLog* pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public unsafe partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + [NativeApi(EntryPoint = "IPropertyBag_Read_Stub")] + public partial int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSTGRemoteNextProxy(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Proxy")] + public partial int IEnumSTATPROPSTGRemoteNextProxy(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_RemoteNext_Stub")] + public partial void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGRemoteNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Proxy")] + public partial int IEnumSTATPROPSETSTGRemoteNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_RemoteNext_Stub")] + public partial void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize")] + public unsafe partial uint LPSAFEARRAYUserSize(uint* arg0, uint arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize")] + public unsafe partial uint LPSAFEARRAYUserSize(uint* arg0, uint arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize")] + public unsafe partial uint LPSAFEARRAYUserSize(ref uint arg0, uint arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize")] + public unsafe partial uint LPSAFEARRAYUserSize(ref uint arg0, uint arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal")] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal")] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree")] + public unsafe partial void LPSAFEARRAYUserFree(uint* arg0, SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree")] + public unsafe partial void LPSAFEARRAYUserFree(uint* arg0, ref SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree")] + public unsafe partial void LPSAFEARRAYUserFree(ref uint arg0, SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree")] + public unsafe partial void LPSAFEARRAYUserFree(ref uint arg0, ref SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize64")] + public unsafe partial uint LPSAFEARRAYUserSize64(uint* arg0, uint arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize64")] + public unsafe partial uint LPSAFEARRAYUserSize64(uint* arg0, uint arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize64")] + public unsafe partial uint LPSAFEARRAYUserSize64(ref uint arg0, uint arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize64")] + public unsafe partial uint LPSAFEARRAYUserSize64(ref uint arg0, uint arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial byte* LPSAFEARRAYUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal64")] + public unsafe partial string LPSAFEARRAYUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, byte* arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, byte* arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, ref byte arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, ref byte arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal64")] + public unsafe partial string LPSAFEARRAYUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree64")] + public unsafe partial void LPSAFEARRAYUserFree64(uint* arg0, SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree64")] + public unsafe partial void LPSAFEARRAYUserFree64(uint* arg0, ref SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree64")] + public unsafe partial void LPSAFEARRAYUserFree64(ref uint arg0, SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree64")] + public unsafe partial void LPSAFEARRAYUserFree64(ref uint arg0, ref SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSTGNextProxy(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Proxy")] + public partial int IEnumSTATPROPSTGNextProxy(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(IEnumSTATPROPSTG* This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(ref IEnumSTATPROPSTG This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSTGNextStub(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSTG_Next_Stub")] + public partial int IEnumSTATPROPSTGNextStub(ref IEnumSTATPROPSTG This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public unsafe partial int IEnumSTATPROPSETSTGNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Proxy")] + public partial int IEnumSTATPROPSETSTGNextProxy(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(IEnumSTATPROPSETSTG* This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(ref IEnumSTATPROPSETSTG This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public unsafe partial int IEnumSTATPROPSETSTGNextStub(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + [NativeApi(EntryPoint = "IEnumSTATPROPSETSTG_Next_Stub")] + public partial int IEnumSTATPROPSETSTGNextStub(ref IEnumSTATPROPSETSTG This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantCopy")] + public unsafe partial int PropVariantCopy(PropVariant* pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvarSrc); + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantCopy")] + public unsafe partial int PropVariantCopy(PropVariant* pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvarSrc); + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantCopy")] + public unsafe partial int PropVariantCopy(ref PropVariant pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvarSrc); + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantCopy")] + public partial int PropVariantCopy(ref PropVariant pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvarSrc); + + /// To be documented. + [NativeName("Src", "Line 1219, Column 11 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantClear")] + public unsafe partial int PropVariantClear(PropVariant* pvar); + + /// To be documented. + [NativeName("Src", "Line 1219, Column 11 in propidl.h")] + [NativeApi(EntryPoint = "PropVariantClear")] + public partial int PropVariantClear(ref PropVariant pvar); + + /// To be documented. + [NativeName("Src", "Line 1221, Column 11 in propidl.h")] + [NativeApi(EntryPoint = "FreePropVariantArray")] + public unsafe partial int FreePropVariantArray(uint cVariants, PropVariant* rgvars); + + /// To be documented. + [NativeName("Src", "Line 1221, Column 11 in propidl.h")] + [NativeApi(EntryPoint = "FreePropVariantArray")] + public partial int FreePropVariantArray(uint cVariants, ref PropVariant rgvars); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, ref uint pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, ref uint pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, ref SerializedPropertyValue pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, ref SerializedPropertyValue pprop, uint* pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, ref SerializedPropertyValue pprop, ref uint pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, ref SerializedPropertyValue pprop, ref uint pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, SerializedPropertyValue* pprop, ref uint pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, SerializedPropertyValue* pprop, ref uint pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, ref SerializedPropertyValue pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, ref SerializedPropertyValue pprop, uint* pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, ref SerializedPropertyValue pprop, ref uint pcb, uint pid, byte fReserved, uint* pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertVariantToProperty")] + public unsafe partial SerializedPropertyValue* StgConvertVariantToProperty([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in PropVariant pvar, ushort CodePage, ref SerializedPropertyValue pprop, ref uint pcb, uint pid, byte fReserved, ref uint pcIndirect); + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertPropertyToVariant")] + public unsafe partial byte StgConvertPropertyToVariant([Flow(Silk.NET.Core.Native.FlowDirection.In)] SerializedPropertyValue* pprop, ushort CodePage, PropVariant* pvar, PMemoryAllocator* pma); + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertPropertyToVariant")] + public unsafe partial byte StgConvertPropertyToVariant([Flow(Silk.NET.Core.Native.FlowDirection.In)] SerializedPropertyValue* pprop, ushort CodePage, ref PropVariant pvar, PMemoryAllocator* pma); + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertPropertyToVariant")] + public unsafe partial byte StgConvertPropertyToVariant([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in SerializedPropertyValue pprop, ushort CodePage, PropVariant* pvar, PMemoryAllocator* pma); + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + [NativeApi(EntryPoint = "StgConvertPropertyToVariant")] + public unsafe partial byte StgConvertPropertyToVariant([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in SerializedPropertyValue pprop, ushort CodePage, ref PropVariant pvar, PMemoryAllocator* pma); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(IEnumConnections* This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(IEnumConnections* This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionsRemoteNextProxy(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Proxy")] + public partial int IEnumConnectionsRemoteNextProxy(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_RemoteNext_Stub")] + public partial void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Proxy")] + public unsafe partial int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public unsafe partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_RemoteNext_Stub")] + public partial void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public unsafe partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_RemoteCreateInstanceLic_Stub")] + public partial void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public unsafe partial int IPersistMemoryRemoteLoadProxy(IPersistMemory* This, byte* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public unsafe partial int IPersistMemoryRemoteLoadProxy(IPersistMemory* This, ref byte pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public unsafe partial int IPersistMemoryRemoteLoadProxy(IPersistMemory* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public unsafe partial int IPersistMemoryRemoteLoadProxy(ref IPersistMemory This, byte* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public partial int IPersistMemoryRemoteLoadProxy(ref IPersistMemory This, ref byte pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Proxy")] + public partial int IPersistMemoryRemoteLoadProxy(ref IPersistMemory This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public unsafe partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteLoad_Stub")] + public partial void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public unsafe partial int IPersistMemoryRemoteSaveProxy(IPersistMemory* This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public unsafe partial int IPersistMemoryRemoteSaveProxy(IPersistMemory* This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public unsafe partial int IPersistMemoryRemoteSaveProxy(IPersistMemory* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public unsafe partial int IPersistMemoryRemoteSaveProxy(ref IPersistMemory This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public partial int IPersistMemoryRemoteSaveProxy(ref IPersistMemory This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Proxy")] + public partial int IPersistMemoryRemoteSaveProxy(ref IPersistMemory This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public unsafe partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_RemoteSave_Stub")] + public partial void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Proxy")] + public unsafe partial int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public unsafe partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_RemoteNext_Stub")] + public partial void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6819, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Proxy")] + public unsafe partial int IAdviseSinkExRemoteOnViewStatusChangeProxy(IAdviseSinkEx* This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 6819, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Proxy")] + public partial int IAdviseSinkExRemoteOnViewStatusChangeProxy(ref IAdviseSinkEx This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public unsafe partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_RemoteOnViewStatusChange_Stub")] + public partial void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public unsafe partial int IQuickActivateRemoteQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Proxy")] + public partial int IQuickActivateRemoteQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public unsafe partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_RemoteQuickActivate_Stub")] + public partial void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize")] + public unsafe partial uint HACCELUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize")] + public unsafe partial uint HACCELUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize")] + public unsafe partial uint HACCELUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize")] + public unsafe partial uint HACCELUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial byte* HACCELUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal")] + public unsafe partial string HACCELUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial byte* HACCELUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal")] + public unsafe partial string HACCELUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree")] + public unsafe partial void HACCELUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree")] + public unsafe partial void HACCELUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree")] + public unsafe partial void HACCELUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree")] + public unsafe partial void HACCELUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize")] + public unsafe partial uint HFONTUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize")] + public unsafe partial uint HFONTUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize")] + public unsafe partial uint HFONTUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize")] + public unsafe partial uint HFONTUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial byte* HFONTUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal")] + public unsafe partial string HFONTUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial byte* HFONTUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal")] + public unsafe partial string HFONTUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree")] + public unsafe partial void HFONTUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree")] + public unsafe partial void HFONTUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree")] + public unsafe partial void HFONTUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree")] + public unsafe partial void HFONTUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize")] + public unsafe partial uint HPALETTEUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize")] + public unsafe partial uint HPALETTEUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize")] + public unsafe partial uint HPALETTEUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize")] + public unsafe partial uint HPALETTEUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal")] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal")] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree")] + public unsafe partial void HPALETTEUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree")] + public unsafe partial void HPALETTEUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree")] + public unsafe partial void HPALETTEUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree")] + public unsafe partial void HPALETTEUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize")] + public unsafe partial uint HRGNUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize")] + public unsafe partial uint HRGNUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize")] + public unsafe partial uint HRGNUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize")] + public unsafe partial uint HRGNUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial byte* HRGNUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal")] + public unsafe partial string HRGNUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial byte* HRGNUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal")] + public unsafe partial string HRGNUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree")] + public unsafe partial void HRGNUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree")] + public unsafe partial void HRGNUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree")] + public unsafe partial void HRGNUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree")] + public unsafe partial void HRGNUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize")] + public unsafe partial uint HWNDUserSize(uint* arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize")] + public unsafe partial uint HWNDUserSize(uint* arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize")] + public unsafe partial uint HWNDUserSize(ref uint arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize")] + public partial uint HWNDUserSize(ref uint arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public partial string HWNDUserMarshalS(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial string HWNDUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public unsafe partial byte* HWNDUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal")] + public partial string HWNDUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public partial string HWNDUserUnmarshalS(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial string HWNDUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public unsafe partial byte* HWNDUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal")] + public partial string HWNDUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree")] + public unsafe partial void HWNDUserFree(uint* arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree")] + public unsafe partial void HWNDUserFree(uint* arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree")] + public unsafe partial void HWNDUserFree(ref uint arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree")] + public partial void HWNDUserFree(ref uint arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize64")] + public unsafe partial uint HACCELUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize64")] + public unsafe partial uint HACCELUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize64")] + public unsafe partial uint HACCELUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserSize64")] + public unsafe partial uint HACCELUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial byte* HACCELUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserMarshal64")] + public unsafe partial string HACCELUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial byte* HACCELUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HACCEL_UserUnmarshal64")] + public unsafe partial string HACCELUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree64")] + public unsafe partial void HACCELUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree64")] + public unsafe partial void HACCELUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree64")] + public unsafe partial void HACCELUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HACCEL_UserFree64")] + public unsafe partial void HACCELUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize64")] + public unsafe partial uint HFONTUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize64")] + public unsafe partial uint HFONTUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize64")] + public unsafe partial uint HFONTUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserSize64")] + public unsafe partial uint HFONTUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial byte* HFONTUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserMarshal64")] + public unsafe partial string HFONTUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial byte* HFONTUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HFONT_UserUnmarshal64")] + public unsafe partial string HFONTUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree64")] + public unsafe partial void HFONTUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree64")] + public unsafe partial void HFONTUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree64")] + public unsafe partial void HFONTUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HFONT_UserFree64")] + public unsafe partial void HFONTUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize64")] + public unsafe partial uint HPALETTEUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize64")] + public unsafe partial uint HPALETTEUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize64")] + public unsafe partial uint HPALETTEUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize64")] + public unsafe partial uint HPALETTEUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial byte* HPALETTEUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal64")] + public unsafe partial string HPALETTEUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial byte* HPALETTEUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal64")] + public unsafe partial string HPALETTEUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree64")] + public unsafe partial void HPALETTEUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree64")] + public unsafe partial void HPALETTEUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree64")] + public unsafe partial void HPALETTEUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree64")] + public unsafe partial void HPALETTEUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize64")] + public unsafe partial uint HRGNUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize64")] + public unsafe partial uint HRGNUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize64")] + public unsafe partial uint HRGNUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserSize64")] + public unsafe partial uint HRGNUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial byte* HRGNUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserMarshal64")] + public unsafe partial string HRGNUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial byte* HRGNUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HRGN_UserUnmarshal64")] + public unsafe partial string HRGNUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree64")] + public unsafe partial void HRGNUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree64")] + public unsafe partial void HRGNUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree64")] + public unsafe partial void HRGNUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HRGN_UserFree64")] + public unsafe partial void HRGNUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize64")] + public unsafe partial uint HWNDUserSize64(uint* arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize64")] + public unsafe partial uint HWNDUserSize64(uint* arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize64")] + public unsafe partial uint HWNDUserSize64(ref uint arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserSize64")] + public partial uint HWNDUserSize64(ref uint arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public partial string HWNDUserMarshal64S(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial string HWNDUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public unsafe partial byte* HWNDUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserMarshal64")] + public partial string HWNDUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public partial string HWNDUserUnmarshal64S(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial string HWNDUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public unsafe partial byte* HWNDUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HWND_UserUnmarshal64")] + public partial string HWNDUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree64")] + public unsafe partial void HWNDUserFree64(uint* arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree64")] + public unsafe partial void HWNDUserFree64(uint* arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree64")] + public unsafe partial void HWNDUserFree64(ref uint arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + [NativeApi(EntryPoint = "HWND_UserFree64")] + public partial void HWNDUserFree64(ref uint arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(IEnumConnections* This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(IEnumConnections* This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public unsafe partial int IEnumConnectionsNextProxy(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Proxy")] + public partial int IEnumConnectionsNextProxy(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(IEnumConnections* This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(IEnumConnections* This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(IEnumConnections* This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(ref IEnumConnections This, uint cConnections, ConnectData* rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public unsafe partial int IEnumConnectionsNextStub(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnections_Next_Stub")] + public partial int IEnumConnectionsNextStub(ref IEnumConnections This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Proxy")] + public unsafe partial int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, IConnectionPoint** ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumConnectionPoints_Next_Stub")] + public unsafe partial int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(Silk.NET.Core.Native.IUnknown* This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Silk.NET.Core.Native.IUnknown* pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Proxy")] + public unsafe partial int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(Silk.NET.Core.Native.IUnknown* This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IClassFactory2_CreateInstanceLic_Stub")] + public unsafe partial int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Proxy")] + public unsafe partial int IPersistMemoryLoadProxy(IPersistMemory* This, void* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Proxy")] + public unsafe partial int IPersistMemoryLoadProxy(IPersistMemory* This, ref T0 pMem, uint cbSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Proxy")] + public unsafe partial int IPersistMemoryLoadProxy(ref IPersistMemory This, void* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Proxy")] + public partial int IPersistMemoryLoadProxy(ref IPersistMemory This, ref T0 pMem, uint cbSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public unsafe partial int IPersistMemoryLoadStub(IPersistMemory* This, byte* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public unsafe partial int IPersistMemoryLoadStub(IPersistMemory* This, ref byte pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public unsafe partial int IPersistMemoryLoadStub(IPersistMemory* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public unsafe partial int IPersistMemoryLoadStub(ref IPersistMemory This, byte* pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public partial int IPersistMemoryLoadStub(ref IPersistMemory This, ref byte pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Load_Stub")] + public partial int IPersistMemoryLoadStub(ref IPersistMemory This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Proxy")] + public unsafe partial int IPersistMemorySaveProxy(IPersistMemory* This, void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Proxy")] + public unsafe partial int IPersistMemorySaveProxy(IPersistMemory* This, ref T0 pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Proxy")] + public unsafe partial int IPersistMemorySaveProxy(ref IPersistMemory This, void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Proxy")] + public partial int IPersistMemorySaveProxy(ref IPersistMemory This, ref T0 pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public unsafe partial int IPersistMemorySaveStub(IPersistMemory* This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public unsafe partial int IPersistMemorySaveStub(IPersistMemory* This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public unsafe partial int IPersistMemorySaveStub(IPersistMemory* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public unsafe partial int IPersistMemorySaveStub(ref IPersistMemory This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public partial int IPersistMemorySaveStub(ref IPersistMemory This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IPersistMemory_Save_Stub")] + public partial int IPersistMemorySaveStub(ref IPersistMemory This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Proxy")] + public unsafe partial int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, IOleUndoUnit** rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IEnumOleUndoUnits_Next_Stub")] + public unsafe partial int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched); + + /// To be documented. + [NativeName("Src", "Line 7203, Column 38 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_OnViewStatusChange_Proxy")] + public unsafe partial void IAdviseSinkExOnViewStatusChangeProxy(IAdviseSinkEx* This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 7203, Column 38 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_OnViewStatusChange_Proxy")] + public partial void IAdviseSinkExOnViewStatusChangeProxy(ref IAdviseSinkEx This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 7208, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_OnViewStatusChange_Stub")] + public unsafe partial int IAdviseSinkExOnViewStatusChangeStub(IAdviseSinkEx* This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 7208, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IAdviseSinkEx_OnViewStatusChange_Stub")] + public partial int IAdviseSinkExOnViewStatusChangeStub(ref IAdviseSinkEx This, uint dwViewStatus); + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public unsafe partial int IQuickActivateQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Proxy")] + public partial int IQuickActivateQuickActivateProxy(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(Silk.NET.Core.Native.IUnknown* This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, QAControl* pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(ref Silk.NET.Core.Native.IUnknown This, void* pQaContainer, ref QAControl pQaControl); + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public unsafe partial int IQuickActivateQuickActivateStub(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + [NativeApi(EntryPoint = "IQuickActivate_QuickActivate_Stub")] + public partial int IQuickActivateQuickActivateStub(ref Silk.NET.Core.Native.IUnknown This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 555, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventUnregister")] + public partial uint EventUnregister(ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 568, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventSetInformation")] + public unsafe partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, void* EventInformation, uint InformationLength); + + /// To be documented. + [NativeName("Src", "Line 568, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventSetInformation")] + public partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, ref T0 EventInformation, uint InformationLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 611, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventEnabled")] + public unsafe partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor); + + /// To be documented. + [NativeName("Src", "Line 611, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventEnabled")] + public partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor); + + /// To be documented. + [NativeName("Src", "Line 652, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventProviderEnabled")] + public partial byte EventProviderEnabled(ulong RegHandle, byte Level, ulong Keyword); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public unsafe partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* String); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char String); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string String); + + /// To be documented. + [NativeName("Src", "Line 781, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventActivityIdControl")] + public unsafe partial uint EventActivityIdControl(uint ControlCode, Guid* ActivityId); + + /// To be documented. + [NativeName("Src", "Line 781, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventActivityIdControl")] + public partial uint EventActivityIdControl(uint ControlCode, ref Guid ActivityId); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTrace")] + public unsafe partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTrace")] + public partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceSetInformation")] + public unsafe partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength); + + /// To be documented. + [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceSetInformation")] + public partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(void* RegHandle, EventInstanceInfo* InstInfo); + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(void* RegHandle, ref EventInstanceInfo InstInfo); + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(ref T0 RegHandle, EventInstanceInfo* InstInfo) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public partial uint CreateTraceInstanceId(ref T0 RegHandle, ref EventInstanceInfo InstInfo) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEvent")] + public unsafe partial uint TraceEvent(ulong TraceHandle, EventTraceHeader* EventTrace); + + /// To be documented. + [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEvent")] + public partial uint TraceEvent(ulong TraceHandle, ref EventTraceHeader EventTrace); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2573, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UnregisterTraceGuids")] + public partial uint UnregisterTraceGuids(ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceLoggerHandle")] + public unsafe partial ulong GetTraceLoggerHandle(void* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceLoggerHandle")] + public partial ulong GetTraceLoggerHandle(ref T0 Buffer) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2587, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceEnableLevel")] + public partial byte GetTraceEnableLevel(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2594, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceEnableFlags")] + public partial uint GetTraceEnableFlags(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceW")] + public unsafe partial ulong OpenTraceW(EventTraceLogfilew* Logfile); + + /// To be documented. + [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceW")] + public partial ulong OpenTraceW(ref EventTraceLogfilew Logfile); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2638, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CloseTrace")] + public partial uint CloseTrace(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] + public unsafe partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] + public partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer); + + /// To be documented. + [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] + public unsafe partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] + public partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer); + + /// To be documented. + [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] + public unsafe partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer, uint BufferSize); + + /// To be documented. + [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] + public partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer, uint BufferSize); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceA")] + public unsafe partial ulong OpenTraceA(EventTraceLogfilea* Logfile); + + /// To be documented. + [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceA")] + public partial ulong OpenTraceA(ref EventTraceLogfilea Logfile); + + /// To be documented. + [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "SetTraceCallback")] + public unsafe partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid, PfnPeventCallback EventCallback); + + /// To be documented. + [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "SetTraceCallback")] + public partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pGuid, PfnPeventCallback EventCallback); + + /// To be documented. + [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RemoveTraceCallback")] + public unsafe partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid); + + /// To be documented. + [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RemoveTraceCallback")] + public partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pGuid); + + /// To be documented. + [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessage")] + public unsafe partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber); + + /// To be documented. + [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessage")] + public partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, byte* MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, ref byte MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, byte* MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, ref byte MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] + public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] + public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] + public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] + public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9611, Column 43 in objidl.h")] + public unsafe int IRunnableObjectRemoteIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectRemoteIsRunningProxy((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12255, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12280, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnSaveProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12291, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnCloseProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12494, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12505, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12518, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12541, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12552, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12563, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12574, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12585, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12938, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15673, Column 38 in objidl.h")] + public unsafe Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectIsRunningProxy((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15677, Column 43 in objidl.h")] + public unsafe int IRunnableObjectIsRunningStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectIsRunningStub((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy(ref This, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy(ref This, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15869, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15875, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnViewChangeStub((IAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnRenameStub(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15890, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnSaveProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15894, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnSaveStub((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15897, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnCloseProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15901, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkOnCloseStub((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15917, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15921, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnDataChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishOnDataChangeStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15924, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15930, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnViewChangeStub((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15935, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15939, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnViewChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishOnViewChangeStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnRenameStub(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15952, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishOnRenameProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15956, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnRenameStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishOnRenameStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15959, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15963, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnSaveStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15966, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15970, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishOnSaveStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15973, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15977, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginOnCloseStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15980, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15984, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishOnCloseStub((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2OnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2OnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 16007, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 16011, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2FinishOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public unsafe int IDispatchRemoteInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchRemoteInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public unsafe void IDispatchRemoteInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDispatchRemoteInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTRemoteNextProxy(ComPtr This, uint celt, Variant* rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTRemoteNextProxy((IEnumVARIANT*) This.Handle, celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTRemoteNextProxy(ComPtr This, uint celt, Variant* rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTRemoteNextProxy((IEnumVARIANT*) This.Handle, celt, rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTRemoteNextProxy(ComPtr This, uint celt, ref Variant rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTRemoteNextProxy((IEnumVARIANT*) This.Handle, celt, ref rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTRemoteNextProxy(ComPtr This, uint celt, ref Variant rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTRemoteNextProxy((IEnumVARIANT*) This.Handle, celt, ref rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public unsafe void IEnumVARIANTRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumVARIANTRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindProxy(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy(ref This, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public unsafe int ITypeCompRemoteBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompRemoteBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public unsafe void ITypeCompRemoteBindTypeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeCompRemoteBindTypeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetTypeAttrProxy(ComPtr This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetTypeAttrProxy((ITypeInfo*) This.Handle, ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetTypeAttrProxy(ComPtr This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetTypeAttrProxy((ITypeInfo*) This.Handle, ppTypeAttr, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetTypeAttrProxy(ComPtr This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetTypeAttrProxy((ITypeInfo*) This.Handle, ref ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetTypeAttrProxy(ComPtr This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetTypeAttrProxy((ITypeInfo*) This.Handle, ref ppTypeAttr, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetFuncDescProxy(ComPtr This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetFuncDescProxy((ITypeInfo*) This.Handle, index, ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetFuncDescProxy(ComPtr This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetFuncDescProxy((ITypeInfo*) This.Handle, index, ppFuncDesc, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetFuncDescProxy(ComPtr This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetFuncDescProxy((ITypeInfo*) This.Handle, index, ref ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetFuncDescProxy(ComPtr This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetFuncDescProxy((ITypeInfo*) This.Handle, index, ref ppFuncDesc, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetVarDescProxy(ComPtr This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetVarDescProxy((ITypeInfo*) This.Handle, index, ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetVarDescProxy(ComPtr This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetVarDescProxy((ITypeInfo*) This.Handle, index, ppVarDesc, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetVarDescProxy(ComPtr This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetVarDescProxy((ITypeInfo*) This.Handle, index, ref ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetVarDescProxy(ComPtr This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetVarDescProxy((ITypeInfo*) This.Handle, index, ref ppVarDesc, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoRemoteGetNamesProxy(This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetNamesProxy((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoRemoteGetNamesProxy(This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetNamesProxy((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, ref pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetNamesProxy((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetNamesProxy((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, ref pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) + { + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoRemoteGetNamesProxy(ref This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetNamesProxy(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) + { + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoRemoteGetNamesProxy(ref This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3205, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalGetIDsOfNamesProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalGetIDsOfNamesProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalGetIDsOfNamesStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalGetIDsOfNamesStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3216, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalInvokeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalInvokeProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalInvokeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalInvokeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDocumentationProxy((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDocumentationProxy(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoRemoteGetDocumentationProxy(ref This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoRemoteGetDllEntryProxy(ref This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetDllEntryStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetDllEntryStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3261, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalAddressOfMemberProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalAddressOfMemberProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalAddressOfMemberStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalAddressOfMemberStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ComPtr This, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return ITypeInfoRemoteCreateInstanceProxy((ITypeInfo*) This.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ComPtr This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteCreateInstanceProxy((ITypeInfo*) This.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ComPtr This, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteCreateInstanceProxy((ITypeInfo*) This.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ComPtr This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteCreateInstanceProxy((ITypeInfo*) This.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return ITypeInfoRemoteCreateInstanceProxy(ref This, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteCreateInstanceProxy(ref This, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteCreateInstanceStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteCreateInstanceStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ComPtr This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ComPtr This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ComPtr This, ref ITypeLib* ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy((ITypeInfo*) This.Handle, ref ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ComPtr This, ref ITypeLib* ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy((ITypeInfo*) This.Handle, ref ppTLib, ref pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy(ref This, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(ref ITypeInfo This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoRemoteGetContainingTypeLibProxy(ref This, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public unsafe void ITypeInfoRemoteGetContainingTypeLibStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoRemoteGetContainingTypeLibStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3298, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalReleaseTypeAttrProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalReleaseTypeAttrProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseTypeAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseTypeAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3309, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalReleaseFuncDescProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalReleaseFuncDescProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseFuncDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseFuncDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3320, Column 51 in oaidl.h")] + public unsafe int ITypeInfoLocalReleaseVarDescProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfoLocalReleaseVarDescProxy((ITypeInfo*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public unsafe void ITypeInfoLocalReleaseVarDescStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfoLocalReleaseVarDescStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeInfo2RemoteGetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2RemoteGetDocumentation2Proxy(ref This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public unsafe void ITypeInfo2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeInfo2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetTypeInfoCountProxy(ComPtr This, uint* pcTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetTypeInfoCountProxy((ITypeLib*) This.Handle, pcTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetTypeInfoCountProxy(ComPtr This, ref uint pcTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetTypeInfoCountProxy((ITypeLib*) This.Handle, ref pcTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetTypeInfoCountStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetTypeInfoCountStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetLibAttrProxy(ComPtr This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetLibAttrProxy((ITypeLib*) This.Handle, ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetLibAttrProxy(ComPtr This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetLibAttrProxy((ITypeLib*) This.Handle, ppTLibAttr, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetLibAttrProxy(ComPtr This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetLibAttrProxy((ITypeLib*) This.Handle, ref ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetLibAttrProxy(ComPtr This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetLibAttrProxy((ITypeLib*) This.Handle, ref ppTLibAttr, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteGetDocumentationProxy((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) + { + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteGetDocumentationProxy(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) + { + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibRemoteGetDocumentationProxy(ref This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteGetDocumentationStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteGetDocumentationStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, ref szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, ref szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteIsNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteIsNameProxy(ref This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteIsNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteIsNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public unsafe int ITypeLibRemoteFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) + { + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibRemoteFindNameProxy(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public unsafe void ITypeLibRemoteFindNameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibRemoteFindNameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4162, Column 51 in oaidl.h")] + public unsafe int ITypeLibLocalReleaseTLibAttrProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLibLocalReleaseTLibAttrProxy((ITypeLib*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public unsafe void ITypeLibLocalReleaseTLibAttrStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLibLocalReleaseTLibAttrStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetLibStatisticsProxy(ComPtr This, uint* pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetLibStatisticsProxy((ITypeLib2*) This.Handle, pcUniqueNames, pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetLibStatisticsProxy(ComPtr This, uint* pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetLibStatisticsProxy((ITypeLib2*) This.Handle, pcUniqueNames, ref pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetLibStatisticsProxy(ComPtr This, ref uint pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetLibStatisticsProxy((ITypeLib2*) This.Handle, ref pcUniqueNames, pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetLibStatisticsProxy(ComPtr This, ref uint pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetLibStatisticsProxy((ITypeLib2*) This.Handle, ref pcUniqueNames, ref pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetLibStatisticsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetLibStatisticsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeLib2RemoteGetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public unsafe int ITypeLib2RemoteGetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2RemoteGetDocumentation2Proxy(ref This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public unsafe void ITypeLib2RemoteGetDocumentation2Stub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ITypeLib2RemoteGetDocumentation2Stub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, in pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public unsafe int IPropertyBagRemoteReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IPropertyBagRemoteReadProxy(ref This, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public unsafe void IPropertyBagRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IPropertyBagRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + public unsafe uint BSTRUserSize(uint* arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + public unsafe uint BSTRUserSize(ref uint arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + public unsafe void BSTRUserFree(uint* arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree(arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + public unsafe void BSTRUserFree(ref uint arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree(ref arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + public unsafe uint BSTRUserSize64(uint* arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize64(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + public unsafe uint BSTRUserSize64(ref uint arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize64(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal64S(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public unsafe byte* BSTRUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal64S(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + public unsafe void BSTRUserFree64(uint* arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree64(arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + public unsafe void BSTRUserFree64(ref uint arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree64(ref arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, riid, lcid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, ref pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public unsafe int IDispatchInvokeProxy(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeProxy((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, uint* rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, Variant* rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public unsafe int IDispatchInvokeStub(ComPtr This, int dispIdMember, ref Guid riid, uint lcid, uint dwFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint pArgErr, uint cVarRef, ref uint rgVarRefIdx, ref Variant rgVarRef) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDispatchInvokeStub((IDispatch*) This.Handle, dispIdMember, ref riid, lcid, dwFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref pArgErr, cVarRef, ref rgVarRefIdx, ref rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public unsafe int IEnumVARIANTNextProxy(ComPtr This, uint celt, Variant* rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextProxy((IEnumVARIANT*) This.Handle, celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public unsafe int IEnumVARIANTNextProxy(ComPtr This, uint celt, Variant* rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextProxy((IEnumVARIANT*) This.Handle, celt, rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public unsafe int IEnumVARIANTNextProxy(ComPtr This, uint celt, ref Variant rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextProxy((IEnumVARIANT*) This.Handle, celt, ref rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public unsafe int IEnumVARIANTNextProxy(ComPtr This, uint celt, ref Variant rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextProxy((IEnumVARIANT*) This.Handle, celt, ref rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTNextStub(ComPtr This, uint celt, Variant* rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextStub((IEnumVARIANT*) This.Handle, celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTNextStub(ComPtr This, uint celt, Variant* rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextStub((IEnumVARIANT*) This.Handle, celt, rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTNextStub(ComPtr This, uint celt, ref Variant rgVar, uint* pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextStub((IEnumVARIANT*) This.Handle, celt, ref rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public unsafe int IEnumVARIANTNextStub(ComPtr This, uint celt, ref Variant rgVar, ref uint pCeltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumVARIANTNextStub((IEnumVARIANT*) This.Handle, celt, ref rgVar, ref pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, BindPtr* pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref BindPtr pBindPtr) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindProxy(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2573, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UnregisterTraceGuids")] - public partial uint UnregisterTraceGuids(ulong RegistrationHandle); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceLoggerHandle")] - public unsafe partial ulong GetTraceLoggerHandle(void* Buffer); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceLoggerHandle")] - public partial ulong GetTraceLoggerHandle(ref T0 Buffer) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2587, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceEnableLevel")] - public partial byte GetTraceEnableLevel(ulong TraceHandle); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2594, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceEnableFlags")] - public partial uint GetTraceEnableFlags(ulong TraceHandle); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceW")] - public unsafe partial ulong OpenTraceW(EventTraceLogfilew* Logfile); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceW")] - public partial ulong OpenTraceW(ref EventTraceLogfilew Logfile); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2638, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CloseTrace")] - public partial uint CloseTrace(ulong TraceHandle); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] - public unsafe partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] - public partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] - public unsafe partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] - public partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] - public unsafe partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer, uint BufferSize); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] - public partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in EtwBufferHeader Buffer, uint BufferSize); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceA")] - public unsafe partial ulong OpenTraceA(EventTraceLogfilea* Logfile); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceA")] - public partial ulong OpenTraceA(ref EventTraceLogfilea Logfile); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "SetTraceCallback")] - public unsafe partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid, PfnPeventCallback EventCallback); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "SetTraceCallback")] - public partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pGuid, PfnPeventCallback EventCallback); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RemoveTraceCallback")] - public unsafe partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RemoveTraceCallback")] - public partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid pGuid); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessage")] - public unsafe partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessage")] - public partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, byte* MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, ref byte MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, byte* MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, ref byte MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); + } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub((ITypeComp*) This.Handle, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } - /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, ref char szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, ref szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] - public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); } /// To be documented. - [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] - public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ComPtr ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, (ITypeInfo**) ppTInfo.GetAddressOf(), ref pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] - public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] - public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), pDummy); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, ref DescKind pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ComPtr ppTypeComp, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindStub(ref This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind, ref ppFuncDesc, ref ppVarDesc, (ITypeComp**) ppTypeComp.GetAddressOf(), ref pDummy); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo, ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, ref szName, lHashVal, ref ppTInfo, ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + return ITypeCompBindTypeProxy((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo, ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } - /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, ref szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo, ref ITypeComp* ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref ppTComp); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public unsafe int ITypeCompBindTypeProxy(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ComPtr ppTComp) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeProxy(ref This, szName, lHashVal, ref ppTInfo, (ITypeComp**) ppTComp.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, char* szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo); } /// To be documented. - [NativeName("Src", "Line 9311, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, ref char szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, ref char szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, ref szName, lHashVal, ref ppTInfo); } /// To be documented. - [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeStub((ITypeComp*) This.Handle, szName, lHashVal, ref ppTInfo); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ref ITypeComp This, char* szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeStub(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ref ITypeComp This, ref char szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeCompBindTypeStub(ref This, ref szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public unsafe int ITypeCompBindTypeStub(ref ITypeComp This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ComPtr ppTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeCompBindTypeStub(ref This, szName, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrProxy(ComPtr This, TypeAttr** ppTypeAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetTypeAttrProxy((ITypeInfo*) This.Handle, ppTypeAttr); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrProxy(ComPtr This, ref TypeAttr* ppTypeAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetTypeAttrProxy((ITypeInfo*) This.Handle, ref ppTypeAttr); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrStub(ComPtr This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetTypeAttrStub((ITypeInfo*) This.Handle, ppTypeAttr, pDummy); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrStub(ComPtr This, TypeAttr** ppTypeAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetTypeAttrStub((ITypeInfo*) This.Handle, ppTypeAttr, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrStub(ComPtr This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetTypeAttrStub((ITypeInfo*) This.Handle, ref ppTypeAttr, pDummy); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetTypeAttrStub(ComPtr This, ref TypeAttr* ppTypeAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetTypeAttrStub((ITypeInfo*) This.Handle, ref ppTypeAttr, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescProxy(ComPtr This, uint index, FuncDesc** ppFuncDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetFuncDescProxy((ITypeInfo*) This.Handle, index, ppFuncDesc); } /// To be documented. - [NativeName("Src", "Line 9323, Column 17 in objidl.h")] - public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescProxy(ComPtr This, uint index, ref FuncDesc* ppFuncDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetFuncDescProxy((ITypeInfo*) This.Handle, index, ref ppFuncDesc); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescStub(ComPtr This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return ITypeInfoGetFuncDescStub((ITypeInfo*) This.Handle, index, ppFuncDesc, pDummy); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescStub(ComPtr This, uint index, FuncDesc** ppFuncDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeInfoGetFuncDescStub((ITypeInfo*) This.Handle, index, ppFuncDesc, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescStub(ComPtr This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeInfoGetFuncDescStub((ITypeInfo*) This.Handle, index, ref ppFuncDesc, pDummy); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetFuncDescStub(ComPtr This, uint index, ref FuncDesc* ppFuncDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeInfoGetFuncDescStub((ITypeInfo*) This.Handle, index, ref ppFuncDesc, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescProxy(ComPtr This, uint index, VarDesc** ppVarDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return ITypeInfoGetVarDescProxy((ITypeInfo*) This.Handle, index, ppVarDesc); } /// To be documented. - [NativeName("Src", "Line 9455, Column 43 in objidl.h")] - public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescProxy(ComPtr This, uint index, ref VarDesc* ppVarDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return ITypeInfoGetVarDescProxy((ITypeInfo*) This.Handle, index, ref ppVarDesc); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescStub(ComPtr This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetVarDescStub((ITypeInfo*) This.Handle, index, ppVarDesc, pDummy); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescStub(ComPtr This, uint index, VarDesc** ppVarDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetVarDescStub((ITypeInfo*) This.Handle, index, ppVarDesc, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescStub(ComPtr This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetVarDescStub((ITypeInfo*) This.Handle, index, ref ppVarDesc, pDummy); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetVarDescStub(ComPtr This, uint index, ref VarDesc* ppVarDesc, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetVarDescStub((ITypeInfo*) This.Handle, index, ref ppVarDesc, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) { - // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesProxy(This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetNamesProxy((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, pcNames); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) { - // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesProxy(This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetNamesProxy((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, ref pcNames); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetNamesProxy((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, pcNames); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetNamesProxy((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, ref pcNames); } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) { - // ComPtrOverloader - IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesProxy(ref This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9462, Column 17 in objidl.h")] - public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetNamesProxy(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) { - // ComPtrOverloader - IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesProxy(ref This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9611, Column 43 in objidl.h")] - public unsafe int IRunnableObjectRemoteIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) { - // ComPtrOverloader - return IRunnableObjectRemoteIsRunningProxy((IRunnableObject*) This.Handle); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesStub(This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetNamesStub((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, pcNames); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ITypeInfo* This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) { - // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesStub(This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ComPtr This, int memid, char** rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetNamesStub((ITypeInfo*) This.Handle, memid, rgBstrNames, cMaxNames, ref pcNames); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetNamesStub((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, pcNames); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ComPtr This, int memid, ref char* rgBstrNames, uint cMaxNames, ref uint pcNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetNamesStub((ITypeInfo*) This.Handle, memid, ref rgBstrNames, cMaxNames, ref pcNames); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, uint* pcNames) { - // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesStub(ref This, memid, rgBstrNames, cMaxNames, pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetNamesStub(ref ITypeInfo This, int memid, string[] rgBstrNamesSa, uint cMaxNames, ref uint pcNames) { - // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var rgBstrNames = (char**) SilkMarshal.StringArrayToPtr(rgBstrNamesSa); + var ret = ITypeInfoGetNamesStub(ref This, memid, rgBstrNames, cMaxNames, ref pcNames); + SilkMarshal.CopyPtrToStringArray((nint) rgBstrNames, rgBstrNamesSa); + SilkMarshal.Free((nint) rgBstrNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, string[] rgszNamesSa, uint cNames, int* pMemId) { - // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = ITypeInfoGetIDsOfNamesProxy(This, rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ComPtr This, char** rgszNames, uint cNames, int* pMemId) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetIDsOfNamesProxy((ITypeInfo*) This.Handle, rgszNames, cNames, pMemId); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ITypeInfo* This, string[] rgszNamesSa, uint cNames, ref int pMemId) { - // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = ITypeInfoGetIDsOfNamesProxy(This, rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ComPtr This, char** rgszNames, uint cNames, ref int pMemId) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetIDsOfNamesProxy((ITypeInfo*) This.Handle, rgszNames, cNames, ref pMemId); } /// To be documented. - [NativeName("Src", "Line 9615, Column 17 in objidl.h")] - public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ComPtr This, ref char* rgszNames, uint cNames, int* pMemId) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetIDsOfNamesProxy((ITypeInfo*) This.Handle, ref rgszNames, cNames, pMemId); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ComPtr This, ref char* rgszNames, uint cNames, ref int pMemId) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoGetIDsOfNamesProxy((ITypeInfo*) This.Handle, ref rgszNames, cNames, ref pMemId); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, string[] rgszNamesSa, uint cNames, int* pMemId) { - // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = ITypeInfoGetIDsOfNamesProxy(ref This, rgszNames, cNames, pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesProxy(ref ITypeInfo This, string[] rgszNamesSa, uint cNames, ref int pMemId) { - // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + // StringArrayOverloader + var rgszNames = (char**) SilkMarshal.StringArrayToPtr(rgszNamesSa); + var ret = ITypeInfoGetIDsOfNamesProxy(ref This, rgszNames, cNames, ref pMemId); + SilkMarshal.CopyPtrToStringArray((nint) rgszNames, rgszNamesSa); + SilkMarshal.Free((nint) rgszNames); + return ret; } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6086, Column 51 in oaidl.h")] + public unsafe int ITypeInfoGetIDsOfNamesStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return ITypeInfoGetIDsOfNamesStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, ref pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, void* pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, ref pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10382, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, Variant* pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ExceptionInfo* pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, uint* puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public unsafe int ITypeInfoInvokeProxy(ComPtr This, ref T0 pvInstance, int memid, ushort wFlags, ref DispatchParams pDispParams, ref Variant pVarResult, ref ExceptionInfo pExcepInfo, ref uint puArgErr) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoInvokeProxy((ITypeInfo*) This.Handle, ref pvInstance, memid, wFlags, ref pDispParams, ref pVarResult, ref pExcepInfo, ref puArgErr); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6100, Column 51 in oaidl.h")] + public unsafe int ITypeInfoInvokeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoInvokeStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10390, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ComPtr This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return ITypeInfoGetDocumentationProxy((ITypeInfo*) This.Handle, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - ppvObj = default; - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10397, Column 43 in objidl.h")] - public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationProxy(ref ITypeInfo This, int memid, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationProxy(ref This, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10405, Column 17 in objidl.h")] - public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10649, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10649, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10649, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10649, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10656, Column 17 in objidl.h")] - public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ComPtr This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDocumentationStub((ITypeInfo*) This.Handle, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDocumentationStub(ref ITypeInfo This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeInfoGetDocumentationStub(ref This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 10998, Column 43 in objidl.h")] - public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) { - // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) { - // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(This, memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, ref pBstrDllName, ref pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11008, Column 17 in objidl.h")] - public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ComPtr This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetDllEntryProxy((ITypeInfo*) This.Handle, memid, invKind, ref pBstrDllName, ref pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryProxy(ref ITypeInfo This, int memid, InvokeKind invKind, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryProxy(ref This, memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) { - // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) { // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); return ret; } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11015, Column 43 in objidl.h")] - public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ComPtr This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ref ushort pwOrdinal) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + return ITypeInfoGetDllEntryStub((ITypeInfo*) This.Handle, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ushort* pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ushort* pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, string[] pBstrDllNameSa, ref char* pBstrName, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDllName = (char**) SilkMarshal.StringArrayToPtr(pBstrDllNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDllName, pBstrDllNameSa); + SilkMarshal.Free((nint) pBstrDllName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ushort* pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetDllEntryStub(ref ITypeInfo This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, string[] pBstrNameSa, ref ushort pwOrdinal) { - // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeInfoGetDllEntryStub(ref This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + public unsafe int ITypeInfoAddressOfMemberProxy(ComPtr This, int memid, InvokeKind invKind, void** ppv) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoAddressOfMemberProxy((ITypeInfo*) This.Handle, memid, invKind, ppv); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + public unsafe int ITypeInfoAddressOfMemberProxy(ComPtr This, int memid, InvokeKind invKind, ref void* ppv) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoAddressOfMemberProxy((ITypeInfo*) This.Handle, memid, invKind, ref ppv); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6151, Column 51 in oaidl.h")] + public unsafe int ITypeInfoAddressOfMemberStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoAddressOfMemberStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + ppvObj = default; + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11023, Column 17 in objidl.h")] - public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + ppvObj = default; + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, ref pUnkOuter, riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, ref pUnkOuter, ref riid, ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy((ITypeInfo*) This.Handle, ref pUnkOuter, ref riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ComPtr pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + ppvObj = default; + return ITypeInfoCreateInstanceProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ComPtr pUnkOuter, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ComPtr pUnkOuter, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ppvObj); } /// To be documented. - [NativeName("Src", "Line 11030, Column 43 in objidl.h")] - public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ComPtr pUnkOuter, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return ITypeInfoCreateInstanceProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + ppvObj = default; + return ITypeInfoCreateInstanceProxy(ref This, ref pUnkOuter, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ComPtr This, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + ppvObj = default; + return ITypeInfoCreateInstanceStub((ITypeInfo*) This.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ComPtr This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoCreateInstanceStub((ITypeInfo*) This.Handle, riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ComPtr This, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoCreateInstanceStub((ITypeInfo*) This.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ComPtr This, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfoCreateInstanceStub((ITypeInfo*) This.Handle, ref riid, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ref ITypeInfo This, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + ppvObj = default; + return ITypeInfoCreateInstanceStub(ref This, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe int ITypeInfoCreateInstanceStub(ref ITypeInfo This, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoCreateInstanceStub(ref This, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ComPtr This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetContainingTypeLibProxy((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ComPtr This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetContainingTypeLibProxy((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ComPtr This, ref ITypeLib* ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetContainingTypeLibProxy((ITypeInfo*) This.Handle, ref ppTLib, pIndex); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ComPtr This, ref ITypeLib* ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetContainingTypeLibProxy((ITypeInfo*) This.Handle, ref ppTLib, ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11039, Column 17 in objidl.h")] - public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoGetContainingTypeLibProxy(ref This, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibProxy(ref ITypeInfo This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + return ITypeInfoGetContainingTypeLibProxy(ref This, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ComPtr This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + return ITypeInfoGetContainingTypeLibStub((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ComPtr This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + return ITypeInfoGetContainingTypeLibStub((ITypeInfo*) This.Handle, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ComPtr This, ref ITypeLib* ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + return ITypeInfoGetContainingTypeLibStub((ITypeInfo*) This.Handle, ref ppTLib, pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ComPtr This, ref ITypeLib* ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + return ITypeInfoGetContainingTypeLibStub((ITypeInfo*) This.Handle, ref ppTLib, ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11539, Column 35 in objidl.h")] - public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ref ComPtr ppTLib, uint* pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + return ITypeInfoGetContainingTypeLibStub(ref This, (ITypeLib**) ppTLib.GetAddressOf(), pIndex); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public unsafe int ITypeInfoGetContainingTypeLibStub(ref ITypeInfo This, ref ComPtr ppTLib, ref uint pIndex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfoGetContainingTypeLibStub(ref This, (ITypeLib**) ppTLib.GetAddressOf(), ref pIndex); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseTypeAttrProxy(ComPtr This, TypeAttr* pTypeAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + ITypeInfoReleaseTypeAttrProxy((ITypeInfo*) This.Handle, pTypeAttr); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseTypeAttrProxy(ComPtr This, ref TypeAttr pTypeAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + ITypeInfoReleaseTypeAttrProxy((ITypeInfo*) This.Handle, ref pTypeAttr); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6182, Column 51 in oaidl.h")] + public unsafe int ITypeInfoReleaseTypeAttrStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoReleaseTypeAttrStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseFuncDescProxy(ComPtr This, FuncDesc* pFuncDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + ITypeInfoReleaseFuncDescProxy((ITypeInfo*) This.Handle, pFuncDesc); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseFuncDescProxy(ComPtr This, ref FuncDesc pFuncDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + ITypeInfoReleaseFuncDescProxy((ITypeInfo*) This.Handle, ref pFuncDesc); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6190, Column 51 in oaidl.h")] + public unsafe int ITypeInfoReleaseFuncDescStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfoReleaseFuncDescStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseVarDescProxy(ComPtr This, VarDesc* pVarDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + ITypeInfoReleaseVarDescProxy((ITypeInfo*) This.Handle, pVarDesc); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + public unsafe void ITypeInfoReleaseVarDescProxy(ComPtr This, ref VarDesc pVarDesc) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + ITypeInfoReleaseVarDescProxy((ITypeInfo*) This.Handle, ref pVarDesc); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6198, Column 51 in oaidl.h")] + public unsafe int ITypeInfoReleaseVarDescStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfoReleaseVarDescStub((ITypeInfo*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11547, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11554, Column 43 in objidl.h")] - public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ComPtr This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Proxy((ITypeInfo2*) This.Handle, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11562, Column 17 in objidl.h")] - public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Proxy(ref ITypeInfo2 This, int memid, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Proxy(ref This, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ComPtr This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeInfo2GetDocumentation2Stub((ITypeInfo2*) This.Handle, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11726, Column 17 in objidl.h")] - public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public unsafe int ITypeInfo2GetDocumentation2Stub(ref ITypeInfo2 This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeInfo2GetDocumentation2Stub(ref This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6221, Column 38 in oaidl.h")] + public unsafe uint ITypeLibGetTypeInfoCountProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetTypeInfoCountProxy((ITypeLib*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetTypeInfoCountStub(ComPtr This, uint* pcTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetTypeInfoCountStub((ITypeLib*) This.Handle, pcTInfo); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetTypeInfoCountStub(ComPtr This, ref uint pcTInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetTypeInfoCountStub((ITypeLib*) This.Handle, ref pcTInfo); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrProxy(ComPtr This, TLibAttr** ppTLibAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetLibAttrProxy((ITypeLib*) This.Handle, ppTLibAttr); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrProxy(ComPtr This, ref TLibAttr* ppTLibAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetLibAttrProxy((ITypeLib*) This.Handle, ref ppTLibAttr); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrStub(ComPtr This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetLibAttrStub((ITypeLib*) This.Handle, ppTLibAttr, pDummy); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrStub(ComPtr This, TLibAttr** ppTLibAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetLibAttrStub((ITypeLib*) This.Handle, ppTLibAttr, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrStub(ComPtr This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetLibAttrStub((ITypeLib*) This.Handle, ref ppTLibAttr, pDummy); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetLibAttrStub(ComPtr This, ref TLibAttr* ppTLibAttr, ref CleanLocalStorage pDummy) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetLibAttrStub((ITypeLib*) This.Handle, ref ppTLibAttr, ref pDummy); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 11887, Column 17 in objidl.h")] - public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12248, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12255, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkRemoteOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(This, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ComPtr This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationProxy((ITypeLib*) This.Handle, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12261, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12268, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12268, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12268, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IAdviseSinkRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationProxy(ref ITypeLib This, int index, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationProxy(ref This, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12273, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12280, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkRemoteOnSaveProxy((IAdviseSink*) This.Handle); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12284, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12291, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return IAdviseSinkRemoteOnCloseProxy((IAdviseSink*) This.Handle); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12295, Column 17 in objidl.h")] - public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, char** pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ComPtr This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + return ITypeLibGetDocumentationStub((ITypeLib*) This.Handle, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); } /// To be documented. - [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, string[] pBstrNameSa, ref char* pBstrDocString, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrName = (char**) SilkMarshal.StringArrayToPtr(pBstrNameSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrName, pBstrNameSa); + SilkMarshal.Free((nint) pBstrName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, uint* pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, string[] pBstrDocStringSa, ref uint pdwHelpContext, ref char* pBstrHelpFile) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrDocString = (char**) SilkMarshal.StringArrayToPtr(pBstrDocStringSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext, ref pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrDocString, pBstrDocStringSa); + SilkMarshal.Free((nint) pBstrDocString); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public unsafe int ITypeLibGetDocumentationStub(ref ITypeLib This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, ref uint pdwHelpContext, string[] pBstrHelpFileSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrHelpFile = (char**) SilkMarshal.StringArrayToPtr(pBstrHelpFileSa); + var ret = ITypeLibGetDocumentationStub(ref This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext, pBstrHelpFile); + SilkMarshal.CopyPtrToStringArray((nint) pBstrHelpFile, pBstrHelpFileSa); + SilkMarshal.Free((nint) pBstrHelpFile); + return ret; } /// To be documented. - [NativeName("Src", "Line 12487, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, int* pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName); } /// To be documented. - [NativeName("Src", "Line 12494, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref int pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, int* pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, pfName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref int pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref pfName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public unsafe int ITypeLibIsNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, ref szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12498, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12505, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibIsNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref pfName, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12511, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, ref szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12518, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - return AsyncIAdviseSinkFinishRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, ref szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, szNameBuf, lHashVal, pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public unsafe int ITypeLibIsNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref int pfName, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibIsNameStub(ref This, szNameBuf, lHashVal, ref pfName, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12522, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12529, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12529, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12529, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12534, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12541, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishRemoteOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public unsafe int ITypeLibFindNameProxy(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameProxy(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound); } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12545, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12552, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12556, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12563, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return AsyncIAdviseSinkFinishRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12567, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12574, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12578, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12585, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12589, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12740, Column 43 in objidl.h")] - public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12740, Column 43 in objidl.h")] - public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12740, Column 43 in objidl.h")] - public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSink2RemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12745, Column 17 in objidl.h")] - public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12926, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12926, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12926, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + return ITypeLibFindNameStub((ITypeLib*) This.Handle, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12931, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12938, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 12942, Column 17 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); + return ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, ref char szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, ref szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, int* rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13178, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ushort* pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pRemoteMedium); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, char** pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ComPtr ppTInfo, ref int rgMemId, ref ushort pcFound, ref char* pBstrLibName) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); + return ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, (ITypeInfo**) ppTInfo.GetAddressOf(), ref rgMemId, ref pcFound, ref pBstrLibName); } /// To be documented. - [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ushort* pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public unsafe int ITypeLibFindNameStub(ref ITypeLib This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, ref int rgMemId, ref ushort pcFound, string[] pBstrLibNameSa) { - // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pBstrLibName = (char**) SilkMarshal.StringArrayToPtr(pBstrLibNameSa); + var ret = ITypeLibFindNameStub(ref This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId, ref pcFound, pBstrLibName); + SilkMarshal.CopyPtrToStringArray((nint) pBstrLibName, pBstrLibNameSa); + SilkMarshal.Free((nint) pBstrLibName); + return ret; } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + public unsafe void ITypeLibReleaseTLibAttrProxy(ComPtr This, TLibAttr* pTLibAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + ITypeLibReleaseTLibAttrProxy((ITypeLib*) This.Handle, pTLibAttr); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + public unsafe void ITypeLibReleaseTLibAttrProxy(ComPtr This, ref TLibAttr pTLibAttr) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + ITypeLibReleaseTLibAttrProxy((ITypeLib*) This.Handle, ref pTLibAttr); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6299, Column 51 in oaidl.h")] + public unsafe int ITypeLibReleaseTLibAttrStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLibReleaseTLibAttrStub((ITypeLib*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsProxy(ComPtr This, uint* pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetLibStatisticsProxy((ITypeLib2*) This.Handle, pcUniqueNames, pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsProxy(ComPtr This, uint* pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetLibStatisticsProxy((ITypeLib2*) This.Handle, pcUniqueNames, ref pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsProxy(ComPtr This, ref uint pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetLibStatisticsProxy((ITypeLib2*) This.Handle, ref pcUniqueNames, pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsProxy(ComPtr This, ref uint pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetLibStatisticsProxy((ITypeLib2*) This.Handle, ref pcUniqueNames, ref pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsStub(ComPtr This, uint* pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetLibStatisticsStub((ITypeLib2*) This.Handle, pcUniqueNames, pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13191, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsStub(ComPtr This, uint* pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetLibStatisticsStub((ITypeLib2*) This.Handle, pcUniqueNames, ref pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsStub(ComPtr This, ref uint pcUniqueNames, uint* pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + return ITypeLib2GetLibStatisticsStub((ITypeLib2*) This.Handle, ref pcUniqueNames, pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetLibStatisticsStub(ComPtr This, ref uint pcUniqueNames, ref uint pcchUniqueNames) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + return ITypeLib2GetLibStatisticsStub((ITypeLib2*) This.Handle, ref pcUniqueNames, ref pcchUniqueNames); } /// To be documented. - [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) + { + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(This, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ComPtr This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Proxy((ITypeLib2*) This.Handle, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13205, Column 17 in objidl.h")] - public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Proxy(ref ITypeLib2 This, int index, uint lcid, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Proxy(ref This, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13830, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13837, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, char** pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ComPtr This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return ITypeLib2GetDocumentation2Stub((ITypeLib2*) This.Handle, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, string[] pbstrHelpStringSa, ref uint pdwHelpStringContext, ref char* pbstrHelpStringDll) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + // StringArrayOverloader + var pbstrHelpString = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext, ref pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpString, pbstrHelpStringSa); + SilkMarshal.Free((nint) pbstrHelpString); + return ret; } /// To be documented. - [NativeName("Src", "Line 13844, Column 35 in objidl.h")] - public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public unsafe int ITypeLib2GetDocumentation2Stub(ref ITypeLib2 This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, ref uint pdwHelpStringContext, string[] pbstrHelpStringDllSa) { - // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + // StringArrayOverloader + var pbstrHelpStringDll = (char**) SilkMarshal.StringArrayToPtr(pbstrHelpStringDllSa); + var ret = ITypeLib2GetDocumentation2Stub(ref This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext, pbstrHelpStringDll); + SilkMarshal.CopyPtrToStringArray((nint) pbstrHelpStringDll, pbstrHelpStringDllSa); + SilkMarshal.Free((nint) pbstrHelpStringDll); + return ret; } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, in pszPropName, pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, in pszPropName, ref pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 13852, Column 17 in objidl.h")] - public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + return IPropertyBagReadProxy((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog); } /// To be documented. - [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + return IPropertyBagReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + return IPropertyBagReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + return IPropertyBagReadProxy(ref This, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + return IPropertyBagReadProxy(ref This, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + return IPropertyBagReadProxy(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public unsafe int IPropertyBagReadProxy(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + return IPropertyBagReadProxy(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle); } /// To be documented. - [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15658, Column 41 in objidl.h")] - public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15667, Column 43 in objidl.h")] - public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15673, Column 38 in objidl.h")] - public unsafe Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IRunnableObjectIsRunningProxy((IRunnableObject*) This.Handle); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15677, Column 43 in objidl.h")] - public unsafe int IRunnableObjectIsRunningStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IRunnableObjectIsRunningStub((IRunnableObject*) This.Handle); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, in pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub((IPropertyBag*) This.Handle, pszPropName, ref pVar, ref pErrorLog, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub(ref This, in pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, in pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + return IPropertyBagReadStub(ref This, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, in pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub(ref This, in pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ComPtr pErrorLog, uint varType, ref Silk.NET.Core.Native.IUnknown pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, (IErrorLog*) pErrorLog.Handle, varType, ref pUnkObj); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public unsafe int IPropertyBagReadStub(ref IPropertyBag This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, ref Variant pVar, ref IErrorLog pErrorLog, uint varType, ComPtr pUnkObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + return IPropertyBagReadStub(ref This, pszPropName, ref pVar, ref pErrorLog, varType, (Silk.NET.Core.Native.IUnknown*) pUnkObj.Handle); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGRemoteNextProxy(ComPtr This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + return IEnumSTATPROPSTGRemoteNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15680, Column 41 in objidl.h")] - public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGRemoteNextProxy(ComPtr This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + return IEnumSTATPROPSTGRemoteNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGRemoteNextProxy(ComPtr This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return IEnumSTATPROPSTGRemoteNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGRemoteNextProxy(ComPtr This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IEnumSTATPROPSTGRemoteNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + IEnumSTATPROPSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(ComPtr This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return IEnumSTATPROPSETSTGRemoteNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(ComPtr This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + return IEnumSTATPROPSETSTGRemoteNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + return IEnumSTATPROPSETSTGRemoteNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + return IEnumSTATPROPSETSTGRemoteNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + IEnumSTATPROPSETSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + IEnumSTATPROPSETSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvResult = default; - return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15692, Column 43 in objidl.h")] - public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public unsafe void IEnumSTATPROPSETSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + IEnumSTATPROPSETSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextProxy(ComPtr This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + return IEnumSTATPROPSTGNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextProxy(ComPtr This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + return IEnumSTATPROPSTGNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextProxy(ComPtr This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + return IEnumSTATPROPSTGNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextProxy(ComPtr This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + return IEnumSTATPROPSTGNextProxy((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextStub(ComPtr This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + return IEnumSTATPROPSTGNextStub((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextStub(ComPtr This, uint celt, STATPROPSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + return IEnumSTATPROPSTGNextStub((IEnumSTATPROPSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextStub(ComPtr This, uint celt, ref STATPROPSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + return IEnumSTATPROPSTGNextStub((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSTGNextStub(ComPtr This, uint celt, ref STATPROPSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + return IEnumSTATPROPSTGNextStub((IEnumSTATPROPSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextProxy(ComPtr This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + return IEnumSTATPROPSETSTGNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextProxy(ComPtr This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + return IEnumSTATPROPSETSTGNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextProxy(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + return IEnumSTATPROPSETSTGNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextProxy(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + return IEnumSTATPROPSETSTGNextProxy((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextStub(ComPtr This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + return IEnumSTATPROPSETSTGNextStub((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextStub(ComPtr This, uint celt, STATPROPSETSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + return IEnumSTATPROPSETSTGNextStub((IEnumSTATPROPSETSTG*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextStub(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ppvObj); + return IEnumSTATPROPSETSTGNextStub((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public unsafe int IEnumSTATPROPSETSTGNextStub(ComPtr This, uint celt, ref STATPROPSETSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + return IEnumSTATPROPSETSTGNextStub((IEnumSTATPROPSETSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsRemoteNextProxy(ComPtr This, uint cConnections, ConnectData* rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + return IEnumConnectionsRemoteNextProxy((IEnumConnections*) This.Handle, cConnections, rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsRemoteNextProxy(ComPtr This, uint cConnections, ConnectData* rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + return IEnumConnectionsRemoteNextProxy((IEnumConnections*) This.Handle, cConnections, rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsRemoteNextProxy(ComPtr This, uint cConnections, ref ConnectData rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + return IEnumConnectionsRemoteNextProxy((IEnumConnections*) This.Handle, cConnections, ref rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsRemoteNextProxy(ComPtr This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + return IEnumConnectionsRemoteNextProxy((IEnumConnections*) This.Handle, cConnections, ref rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + IEnumConnectionsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15699, Column 41 in objidl.h")] - public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + IEnumConnectionsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + IEnumConnectionsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ComPtr This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + return IEnumConnectionPointsRemoteNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ComPtr This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IEnumConnectionPointsRemoteNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + return IEnumConnectionPointsRemoteNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IEnumConnectionPointsRemoteNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + return IEnumConnectionPointsRemoteNextProxy(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsRemoteNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IEnumConnectionPointsRemoteNextProxy(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + IEnumConnectionPointsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public unsafe void IEnumConnectionPointsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + IEnumConnectionPointsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ppvObj = default; - return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15711, Column 43 in objidl.h")] - public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15718, Column 41 in objidl.h")] - public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15718, Column 41 in objidl.h")] - public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15718, Column 41 in objidl.h")] - public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ComPtr This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15718, Column 41 in objidl.h")] - public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15727, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15727, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15727, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15727, Column 43 in objidl.h")] - public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, ref riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public unsafe int IClassFactory2RemoteCreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IClassFactory2RemoteCreateInstanceLicProxy(ref This, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + IClassFactory2RemoteCreateInstanceLicStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public unsafe void IClassFactory2RemoteCreateInstanceLicStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IClassFactory2RemoteCreateInstanceLicStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteLoadProxy(ComPtr This, byte* pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IPersistMemoryRemoteLoadProxy((IPersistMemory*) This.Handle, pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteLoadProxy(ComPtr This, ref byte pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IPersistMemoryRemoteLoadProxy((IPersistMemory*) This.Handle, ref pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteLoadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IPersistMemoryRemoteLoadProxy((IPersistMemory*) This.Handle, pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15733, Column 41 in objidl.h")] - public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteLoadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteLoadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteLoadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteLoadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteLoadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteSaveProxy(ComPtr This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IPersistMemoryRemoteSaveProxy((IPersistMemory*) This.Handle, pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteSaveProxy(ComPtr This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + return IPersistMemoryRemoteSaveProxy((IPersistMemory*) This.Handle, ref pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryRemoteSaveProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IPersistMemoryRemoteSaveProxy((IPersistMemory*) This.Handle, pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public unsafe void IPersistMemoryRemoteSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + IPersistMemoryRemoteSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ComPtr This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IEnumOleUndoUnitsRemoteNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15745, Column 43 in objidl.h")] - public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ComPtr This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + return IEnumOleUndoUnitsRemoteNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + return IEnumOleUndoUnitsRemoteNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + return IEnumOleUndoUnitsRemoteNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + return IEnumOleUndoUnitsRemoteNextProxy(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsRemoteNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + return IEnumOleUndoUnitsRemoteNextProxy(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + IEnumOleUndoUnitsRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IEnumOleUndoUnitsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IEnumOleUndoUnitsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IEnumOleUndoUnitsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public unsafe void IEnumOleUndoUnitsRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IEnumOleUndoUnitsRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6819, Column 43 in ocidl.h")] + public unsafe int IAdviseSinkExRemoteOnViewStatusChangeProxy(ComPtr This, uint dwViewStatus) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + return IAdviseSinkExRemoteOnViewStatusChangeProxy((IAdviseSinkEx*) This.Handle, dwViewStatus); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15754, Column 41 in objidl.h")] - public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IAdviseSinkExRemoteOnViewStatusChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + IAdviseSinkExRemoteOnViewStatusChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IAdviseSinkExRemoteOnViewStatusChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IAdviseSinkExRemoteOnViewStatusChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IAdviseSinkExRemoteOnViewStatusChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public unsafe int IQuickActivateRemoteQuickActivateProxy(ComPtr This, void* pQaContainer, QAControl* pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + return IQuickActivateRemoteQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public unsafe int IQuickActivateRemoteQuickActivateProxy(ComPtr This, void* pQaContainer, ref QAControl pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + return IQuickActivateRemoteQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, ref pQaControl); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public unsafe int IQuickActivateRemoteQuickActivateProxy(ComPtr This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + return IQuickActivateRemoteQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public unsafe int IQuickActivateRemoteQuickActivateProxy(ComPtr This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + return IQuickActivateRemoteQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, ref pQaControl); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); - var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); - SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); - SilkMarshal.Free((nint) snbExclude); - return ret; + // ComPtrOverloader + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15765, Column 43 in objidl.h")] - public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + IQuickActivateRemoteQuickActivateStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, ref ppenum); + IQuickActivateRemoteQuickActivateStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + IQuickActivateRemoteQuickActivateStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, ref ppenum); + IQuickActivateRemoteQuickActivateStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); } - /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public unsafe void IQuickActivateRemoteQuickActivateStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy(ref This, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + IQuickActivateRemoteQuickActivateStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); } /// To be documented. - [NativeName("Src", "Line 15772, Column 41 in objidl.h")] - public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionsNextProxy(ComPtr This, uint cConnections, ConnectData* rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsProxy(ref This, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionsNextProxy((IEnumConnections*) This.Handle, cConnections, rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionsNextProxy(ComPtr This, uint cConnections, ConnectData* rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionsNextProxy((IEnumConnections*) This.Handle, cConnections, rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionsNextProxy(ComPtr This, uint cConnections, ref ConnectData rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + return IEnumConnectionsNextProxy((IEnumConnections*) This.Handle, cConnections, ref rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionsNextProxy(ComPtr This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionsNextProxy((IEnumConnections*) This.Handle, cConnections, ref rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsNextStub(ComPtr This, uint cConnections, ConnectData* rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); + return IEnumConnectionsNextStub((IEnumConnections*) This.Handle, cConnections, rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsNextStub(ComPtr This, uint cConnections, ConnectData* rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionsNextStub((IEnumConnections*) This.Handle, cConnections, rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsNextStub(ComPtr This, uint cConnections, ref ConnectData rgcd, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + return IEnumConnectionsNextStub((IEnumConnections*) This.Handle, cConnections, ref rgcd, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionsNextStub(ComPtr This, uint cConnections, ref ConnectData rgcd, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionsNextStub((IEnumConnections*) This.Handle, cConnections, ref rgcd, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ComPtr This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionPointsNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15784, Column 43 in objidl.h")] - public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ComPtr This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + return IEnumConnectionPointsNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15792, Column 41 in objidl.h")] - public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + return IEnumConnectionPointsNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15792, Column 41 in objidl.h")] - public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + return IEnumConnectionPointsNextProxy((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15792, Column 41 in objidl.h")] - public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + return IEnumConnectionPointsNextProxy(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15792, Column 41 in objidl.h")] - public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextProxy(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + return IEnumConnectionPointsNextProxy(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ComPtr This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + return IEnumConnectionPointsNextStub((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ComPtr This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + return IEnumConnectionPointsNextStub((IEnumConnectionPoints*) This.Handle, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + return IEnumConnectionPointsNextStub((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ComPtr This, uint cConnections, ref IConnectionPoint* ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + return IEnumConnectionPointsNextStub((IEnumConnectionPoints*) This.Handle, cConnections, ref ppCP, ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, uint* pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + return IEnumConnectionPointsNextStub(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), pcFetched); } /// To be documented. - [NativeName("Src", "Line 15802, Column 35 in objidl.h")] - public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public unsafe int IEnumConnectionPointsNextStub(ref IEnumConnectionPoints This, uint cConnections, ref ComPtr ppCP, ref uint pcFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + return IEnumConnectionPointsNextStub(ref This, cConnections, (IConnectionPoint**) ppCP.GetAddressOf(), ref pcFetched); } /// To be documented. - [NativeName("Src", "Line 15809, Column 41 in objidl.h")] - public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15809, Column 41 in objidl.h")] - public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15809, Column 41 in objidl.h")] - public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15809, Column 41 in objidl.h")] - public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15819, Column 43 in objidl.h")] - public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15869, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15875, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnViewChangeStub((IAdviseSink*) This.Handle, dwAspect, lindex); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15880, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15880, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15880, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15886, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15886, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15886, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnRenameStub(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnRenameStub(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15890, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnSaveProxy((IAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15894, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnSaveStub((IAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15897, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSinkOnCloseProxy((IAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15901, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSinkOnCloseStub((IAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pUnkOuter, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15917, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15921, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishOnDataChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishOnDataChangeStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15924, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15930, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnViewChangeStub((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15935, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15939, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishOnViewChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishOnViewChangeStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15942, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15942, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15942, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15948, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15948, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15948, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnRenameStub(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15952, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishOnRenameProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15956, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishOnRenameStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishOnRenameStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15959, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnSaveProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15963, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnSaveStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15966, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishOnSaveProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15970, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ComPtr pUnkOuter, ref Silk.NET.Core.Native.IUnknown pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishOnSaveStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, (Silk.NET.Core.Native.IUnknown*) pUnkOuter.Handle, ref pUnkReserved, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15973, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkBeginOnCloseProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15977, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkBeginOnCloseStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15980, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkFinishOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSinkFinishOnCloseProxy((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15984, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkFinishOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSinkFinishOnCloseStub((AsyncIAdviseSink*) This.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15987, Column 38 in objidl.h")] - public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15987, Column 38 in objidl.h")] - public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15987, Column 38 in objidl.h")] - public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IAdviseSink2OnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15993, Column 43 in objidl.h")] - public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, char* bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15993, Column 43 in objidl.h")] - public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15993, Column 43 in objidl.h")] - public unsafe int IAdviseSink2OnLinkSrcChangeStub(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, ref char bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IAdviseSink2OnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15997, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ppvObj); } /// To be documented. - [NativeName("Src", "Line 15997, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicProxy(ref Silk.NET.Core.Native.IUnknown This, ref Silk.NET.Core.Native.IUnknown pUnkOuter, ComPtr pUnkReserved, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicProxy(ref This, ref pUnkOuter, (Silk.NET.Core.Native.IUnknown*) pUnkReserved.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 15997, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16003, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16003, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, ref pmk); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16003, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16007, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - AsyncIAdviseSink2FinishOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16011, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return AsyncIAdviseSink2FinishOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pmedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pmedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pmedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, ref char bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pmedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, ref bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ComPtr This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); + return IClassFactory2CreateInstanceLicStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref riid, bstrKey, ref ppvObj); } /// To be documented. - [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); + return IClassFactory2CreateInstanceLicStub(ref This, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); + return IClassFactory2CreateInstanceLicStub(ref This, riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pmedium); + return IClassFactory2CreateInstanceLicStub(ref This, riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, char* bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pmedium); + return IClassFactory2CreateInstanceLicStub(ref This, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, ref char bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pmedium); + return IClassFactory2CreateInstanceLicStub(ref This, ref riid, ref bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public unsafe int IClassFactory2CreateInstanceLicStub(ref Silk.NET.Core.Native.IUnknown This, ref Guid riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium); + return IClassFactory2CreateInstanceLicStub(ref This, ref riid, bstrKey, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + public unsafe int IPersistMemoryLoadProxy(ComPtr This, void* pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, pRemoteMedium); + return IPersistMemoryLoadProxy((IPersistMemory*) This.Handle, pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + public unsafe int IPersistMemoryLoadProxy(ComPtr This, ref T0 pMem, uint cbSize) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); + return IPersistMemoryLoadProxy((IPersistMemory*) This.Handle, ref pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryLoadStub(ComPtr This, byte* pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); + return IPersistMemoryLoadStub((IPersistMemory*) This.Handle, pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryLoadStub(ComPtr This, ref byte pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); + return IPersistMemoryLoadStub((IPersistMemory*) This.Handle, ref pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public unsafe int IPersistMemoryLoadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + return IPersistMemoryLoadStub((IPersistMemory*) This.Handle, pMem, cbSize); } /// To be documented. - [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + public unsafe int IPersistMemorySaveProxy(ComPtr This, void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + return IPersistMemorySaveProxy((IPersistMemory*) This.Handle, pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + public unsafe int IPersistMemorySaveProxy(ComPtr This, ref T0 pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + return IPersistMemorySaveProxy((IPersistMemory*) This.Handle, ref pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public unsafe int IPersistMemorySaveStub(ComPtr This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + return IPersistMemorySaveStub((IPersistMemory*) This.Handle, pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public unsafe int IPersistMemorySaveStub(ComPtr This, ref byte pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + return IPersistMemorySaveStub((IPersistMemory*) This.Handle, ref pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public unsafe int IPersistMemorySaveStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + return IPersistMemorySaveStub((IPersistMemory*) This.Handle, pMem, fClearDirty, cbSize); } /// To be documented. - [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ComPtr This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + return IEnumOleUndoUnitsNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ComPtr This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + return IEnumOleUndoUnitsNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16055, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + return IEnumOleUndoUnitsNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16055, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + return IEnumOleUndoUnitsNextProxy((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16055, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + return IEnumOleUndoUnitsNextProxy(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16055, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextProxy(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + return IEnumOleUndoUnitsNextProxy(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ComPtr This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + return IEnumOleUndoUnitsNextStub((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ComPtr This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + return IEnumOleUndoUnitsNextStub((IEnumOleUndoUnits*) This.Handle, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + return IEnumOleUndoUnitsNextStub((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ComPtr This, uint cElt, ref IOleUndoUnit* rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + return IEnumOleUndoUnitsNextStub((IEnumOleUndoUnits*) This.Handle, cElt, ref rgElt, ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, uint* pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + return IEnumOleUndoUnitsNextStub(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16065, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public unsafe int IEnumOleUndoUnitsNextStub(ref IEnumOleUndoUnits This, uint cElt, ref ComPtr rgElt, ref uint pcEltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + return IEnumOleUndoUnitsNextStub(ref This, cElt, (IOleUndoUnit**) rgElt.GetAddressOf(), ref pcEltFetched); } /// To be documented. - [NativeName("Src", "Line 16071, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7203, Column 38 in ocidl.h")] + public unsafe void IAdviseSinkExOnViewStatusChangeProxy(ComPtr This, uint dwViewStatus) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + IAdviseSinkExOnViewStatusChangeProxy((IAdviseSinkEx*) This.Handle, dwViewStatus); } /// To be documented. - [NativeName("Src", "Line 16071, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7208, Column 43 in ocidl.h")] + public unsafe int IAdviseSinkExOnViewStatusChangeStub(ComPtr This, uint dwViewStatus) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IAdviseSinkExOnViewStatusChangeStub((IAdviseSinkEx*) This.Handle, dwViewStatus); } /// To be documented. - [NativeName("Src", "Line 16071, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateProxy(ComPtr This, void* pQaContainer, QAControl* pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + return IQuickActivateQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 16071, Column 41 in objidl.h")] - public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateProxy(ComPtr This, void* pQaContainer, ref QAControl pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + return IQuickActivateQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, ref pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateProxy(ComPtr This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return IQuickActivateQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateProxy(ComPtr This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IQuickActivateQuickActivateProxy((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, ref pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateStub(ComPtr This, void* pQaContainer, QAControl* pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + return IQuickActivateQuickActivateStub((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateStub(ComPtr This, void* pQaContainer, ref QAControl pQaControl) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + return IQuickActivateQuickActivateStub((Silk.NET.Core.Native.IUnknown*) This.Handle, pQaContainer, ref pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateStub(ComPtr This, ref T0 pQaContainer, QAControl* pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + return IQuickActivateQuickActivateStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, pQaControl); } /// To be documented. - [NativeName("Src", "Line 16083, Column 35 in objidl.h")] - public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public unsafe int IQuickActivateQuickActivateStub(ComPtr This, ref T0 pQaContainer, ref QAControl pQaControl) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + return IQuickActivateQuickActivateStub((Silk.NET.Core.Native.IUnknown*) This.Handle, ref pQaContainer, ref pQaControl); } /// To be documented. @@ -44057,6 +92472,78 @@ public unsafe ComPtr IMonikerBindToStorageStub(ref IMoniker This, ref return silkRet; } + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe ComPtr ITypeInfoRemoteCreateInstanceProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoRemoteCreateInstanceProxy(This, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public unsafe ComPtr ITypeInfoRemoteCreateInstanceProxy(ref ITypeInfo This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoRemoteCreateInstanceProxy(ref This, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceProxy(ComPtr This, ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceProxy(This, pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceProxy(ComPtr This, ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceProxy(This, ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ComPtr pUnkOuter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceProxy(ref This, pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceProxy(ref ITypeInfo This, ref Silk.NET.Core.Native.IUnknown pUnkOuter) where TI0 : unmanaged, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceProxy(ref This, ref pUnkOuter, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceStub(This, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public unsafe ComPtr ITypeInfoCreateInstanceStub(ref ITypeInfo This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(ITypeInfoCreateInstanceStub(ref This, out ComPtr silkRet)); + return silkRet; + } + public Windows(INativeContext ctx) : base(ctx) diff --git a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs index e05636449d..b781abae48 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs @@ -24040,6 +24040,28158 @@ public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, SpanTo be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 2449, Column 43 in oaidl.h")] + public static unsafe int IDispatchRemoteInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchRemoteInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2464, Column 17 in oaidl.h")] + public static unsafe void IDispatchRemoteInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDispatchRemoteInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(This, celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(This, celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(This, celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, Span This, uint celt, Variant* rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(ref This.GetPinnableReference(), celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, Span This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(ref This.GetPinnableReference(), celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2592, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2599, Column 17 in oaidl.h")] + public static unsafe void IEnumVARIANTRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumVARIANTRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 2743, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2756, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2763, Column 43 in oaidl.h")] + public static unsafe int ITypeCompRemoteBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompRemoteBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2770, Column 17 in oaidl.h")] + public static unsafe void ITypeCompRemoteBindTypeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeCompRemoteBindTypeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, ITypeInfo* This, TypeAttr** ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(This, ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, ITypeInfo* This, ref TypeAttr* ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(This, ref ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, Span This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(ref This.GetPinnableReference(), ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, Span This, TypeAttr** ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(ref This.GetPinnableReference(), ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, Span This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(ref This.GetPinnableReference(), ref ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3149, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetTypeAttrProxy(this Windows thisApi, Span This, ref TypeAttr* ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetTypeAttrProxy(ref This.GetPinnableReference(), ref ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3155, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(This, index, ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(This, index, ref ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, Span This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(ref This.GetPinnableReference(), index, ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, Span This, uint index, FuncDesc** ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(ref This.GetPinnableReference(), index, ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, Span This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(ref This.GetPinnableReference(), index, ref ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3162, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetFuncDescProxy(this Windows thisApi, Span This, uint index, ref FuncDesc* ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetFuncDescProxy(ref This.GetPinnableReference(), index, ref ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3169, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, ITypeInfo* This, uint index, VarDesc** ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(This, index, ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(This, index, ref ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, Span This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(ref This.GetPinnableReference(), index, ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, Span This, uint index, VarDesc** ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(ref This.GetPinnableReference(), index, ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, Span This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(ref This.GetPinnableReference(), index, ref ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 3176, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetVarDescProxy(this Windows thisApi, Span This, uint index, ref VarDesc* ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetVarDescProxy(ref This.GetPinnableReference(), index, ref ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3183, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(This, memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(This, memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 3190, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetNamesProxy(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetNamesProxy(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3198, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3205, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalGetIDsOfNamesProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalGetIDsOfNamesProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3209, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalGetIDsOfNamesStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalGetIDsOfNamesStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3216, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalInvokeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalInvokeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3220, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalInvokeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalInvokeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3227, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDocumentationProxy(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDocumentationProxy(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3237, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(This, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 3244, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3254, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetDllEntryStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetDllEntryStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3261, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalAddressOfMemberProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalAddressOfMemberProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3265, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalAddressOfMemberStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalAddressOfMemberStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(This, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(This, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, Span This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(ref This.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, Span This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(ref This.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, Span This, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3272, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteCreateInstanceProxy(this Windows thisApi, Span This, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteCreateInstanceProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3278, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteCreateInstanceStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteCreateInstanceStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, ITypeInfo* This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(This, ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, ITypeInfo* This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(This, ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, Span This, ITypeLib** ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(ref This.GetPinnableReference(), ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, Span This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(ref This.GetPinnableReference(), ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, Span This, ref ITypeLib* ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(ref This.GetPinnableReference(), ref ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 3285, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoRemoteGetContainingTypeLibProxy(this Windows thisApi, Span This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoRemoteGetContainingTypeLibProxy(ref This.GetPinnableReference(), ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3291, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoRemoteGetContainingTypeLibStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoRemoteGetContainingTypeLibStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3298, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalReleaseTypeAttrProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalReleaseTypeAttrProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3302, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseTypeAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseTypeAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3309, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalReleaseFuncDescProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalReleaseFuncDescProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3313, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseFuncDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseFuncDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3320, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoLocalReleaseVarDescProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoLocalReleaseVarDescProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3324, Column 17 in oaidl.h")] + public static unsafe void ITypeInfoLocalReleaseVarDescStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfoLocalReleaseVarDescStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3810, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 3820, Column 17 in oaidl.h")] + public static unsafe void ITypeInfo2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeInfo2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetTypeInfoCountProxy(this Windows thisApi, ITypeLib* This, Span pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetTypeInfoCountProxy(This, ref pcTInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetTypeInfoCountProxy(this Windows thisApi, Span This, uint* pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetTypeInfoCountProxy(ref This.GetPinnableReference(), pcTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 4088, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetTypeInfoCountProxy(this Windows thisApi, Span This, Span pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetTypeInfoCountProxy(ref This.GetPinnableReference(), ref pcTInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4093, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetTypeInfoCountStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetTypeInfoCountStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, ITypeLib* This, TLibAttr** ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(This, ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, ITypeLib* This, ref TLibAttr* ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(This, ref ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, Span This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(ref This.GetPinnableReference(), ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, Span This, TLibAttr** ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(ref This.GetPinnableReference(), ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, Span This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(ref This.GetPinnableReference(), ref ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 4100, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetLibAttrProxy(this Windows thisApi, Span This, ref TLibAttr* ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetLibAttrProxy(ref This.GetPinnableReference(), ref ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4106, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4113, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteGetDocumentationProxy(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibRemoteGetDocumentationProxy(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4123, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteGetDocumentationStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteGetDocumentationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4130, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4138, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteIsNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteIsNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4145, Column 43 in oaidl.h")] + public static unsafe int ITypeLibRemoteFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibRemoteFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4155, Column 17 in oaidl.h")] + public static unsafe void ITypeLibRemoteFindNameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibRemoteFindNameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4162, Column 51 in oaidl.h")] + public static unsafe int ITypeLibLocalReleaseTLibAttrProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeLibLocalReleaseTLibAttrProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4166, Column 17 in oaidl.h")] + public static unsafe void ITypeLibLocalReleaseTLibAttrStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLibLocalReleaseTLibAttrStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(This, pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(This, ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(This, ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, Span This, uint* pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(ref This.GetPinnableReference(), pcUniqueNames, pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, Span This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(ref This.GetPinnableReference(), pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, Span This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 4418, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetLibStatisticsProxy(this Windows thisApi, Span This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetLibStatisticsProxy(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4424, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetLibStatisticsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetLibStatisticsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4431, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2RemoteGetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2RemoteGetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4441, Column 17 in oaidl.h")] + public static unsafe void ITypeLib2RemoteGetDocumentation2Stub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ITypeLib2RemoteGetDocumentation2Stub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 5627, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagRemoteReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagRemoteReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5636, Column 17 in oaidl.h")] + public static unsafe void IPropertyBagRemoteReadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPropertyBagRemoteReadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + public static unsafe uint BSTRUserSize(this Windows thisApi, Span arg0, uint arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5912, Column 39 in oaidl.h")] + public static unsafe uint BSTRUserSize(this Windows thisApi, Span arg0, uint arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5913, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5914, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + public static unsafe void BSTRUserFree(this Windows thisApi, Span arg0, char** arg1) + { + // SpanOverloader + thisApi.BSTRUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5915, Column 39 in oaidl.h")] + public static unsafe void BSTRUserFree(this Windows thisApi, Span arg0, ref char* arg1) + { + // SpanOverloader + thisApi.BSTRUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize(this Windows thisApi, Span arg0, uint arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5917, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, uint* arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, byte* arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5918, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5919, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree(this Windows thisApi, Span arg0, CleanLocalStorage* arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5920, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize(this Windows thisApi, Span arg0, uint arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5922, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5923, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5924, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree(this Windows thisApi, Span arg0, Variant* arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5925, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + public static unsafe uint BSTRUserSize64(this Windows thisApi, Span arg0, uint arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5927, Column 39 in oaidl.h")] + public static unsafe uint BSTRUserSize64(this Windows thisApi, Span arg0, uint arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5928, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5929, Column 29 in oaidl.h")] + public static unsafe byte* BSTRUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + public static unsafe void BSTRUserFree64(this Windows thisApi, Span arg0, char** arg1) + { + // SpanOverloader + thisApi.BSTRUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5930, Column 39 in oaidl.h")] + public static unsafe void BSTRUserFree64(this Windows thisApi, Span arg0, ref char* arg1) + { + // SpanOverloader + thisApi.BSTRUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize64(this Windows thisApi, Span arg0, uint arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5932, Column 39 in oaidl.h")] + public static unsafe uint CLEANLOCALSTORAGEUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5933, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, CleanLocalStorage* arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5934, Column 29 in oaidl.h")] + public static unsafe byte* CLEANLOCALSTORAGEUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLEANLOCALSTORAGEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree64(this Windows thisApi, Span arg0, CleanLocalStorage* arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5935, Column 39 in oaidl.h")] + public static unsafe void CLEANLOCALSTORAGEUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.CLEANLOCALSTORAGEUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize64(this Windows thisApi, Span arg0, uint arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5937, Column 39 in oaidl.h")] + public static unsafe uint VARIANTUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5938, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Variant* arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 5939, Column 29 in oaidl.h")] + public static unsafe byte* VARIANTUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.VARIANTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree64(this Windows thisApi, Span arg0, Variant* arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 5940, Column 39 in oaidl.h")] + public static unsafe void VARIANTUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.VARIANTUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(This, dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, riid, lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 5942, Column 41 in oaidl.h")] + public static unsafe int IDispatchInvokeProxy(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.IDispatchInvokeProxy(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, IDispatch* This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(This, dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Guid* riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, riid, lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), pArgErr, cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, uint* rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, rgVarRefIdx, ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Variant* rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), rgVarRef); + } + + /// To be documented. + [NativeName("Src", "Line 5962, Column 43 in oaidl.h")] + public static unsafe int IDispatchInvokeStub(this Windows thisApi, Span This, int dispIdMember, Span riid, uint lcid, uint dwFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span pArgErr, uint cVarRef, Span rgVarRefIdx, Span rgVarRef) + { + // SpanOverloader + return thisApi.IDispatchInvokeStub(ref This.GetPinnableReference(), dispIdMember, ref riid.GetPinnableReference(), lcid, dwFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref pArgErr.GetPinnableReference(), cVarRef, ref rgVarRefIdx.GetPinnableReference(), ref rgVarRef.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(This, celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(This, celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(This, celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, Span This, uint celt, Variant* rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(ref This.GetPinnableReference(), celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, Span This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(ref This.GetPinnableReference(), celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, Span This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5976, Column 41 in oaidl.h")] + public static unsafe int IEnumVARIANTNextProxy(this Windows thisApi, Span This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextProxy(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, IEnumVARIANT* This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(This, celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(This, celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, IEnumVARIANT* This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(This, celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, Span This, uint celt, Variant* rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(ref This.GetPinnableReference(), celt, rgVar, pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, Span This, uint celt, Variant* rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(ref This.GetPinnableReference(), celt, rgVar, ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, Span This, uint celt, Span rgVar, uint* pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), pCeltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5983, Column 43 in oaidl.h")] + public static unsafe int IEnumVARIANTNextStub(this Windows thisApi, Span This, uint celt, Span rgVar, Span pCeltFetched) + { + // SpanOverloader + return thisApi.IEnumVARIANTNextStub(ref This.GetPinnableReference(), celt, ref rgVar.GetPinnableReference(), ref pCeltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, BindPtr* pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), pBindPtr); + } + + /// To be documented. + [NativeName("Src", "Line 5989, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, Span pBindPtr) + { + // SpanOverloader + return thisApi.ITypeCompBindProxy(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref pBindPtr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, ITypeComp* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(This, szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ITypeInfo** ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, DescKind* pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, pDescKind, ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, FuncDesc** ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, VarDesc** ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ITypeComp** ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6000, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ushort wFlags, ref ITypeInfo* ppTInfo, Span pDescKind, ref FuncDesc* ppFuncDesc, ref VarDesc* ppVarDesc, ref ITypeComp* ppTypeComp, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeCompBindStub(ref This.GetPinnableReference(), szName, lHashVal, wFlags, ref ppTInfo, ref pDescKind.GetPinnableReference(), ref ppFuncDesc, ref ppVarDesc, ref ppTypeComp, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(This, ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ref ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ITypeComp** ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo, ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6012, Column 41 in oaidl.h")] + public static unsafe int ITypeCompBindTypeProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo, ref ITypeComp* ppTComp) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeProxy(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo, ref ppTComp); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(This, ref szName.GetPinnableReference(), lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, ITypeComp* This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(This, ref szName.GetPinnableReference(), lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, char* szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, Span szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), ref szName.GetPinnableReference(), lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ITypeInfo** ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), szName, lHashVal, ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6021, Column 43 in oaidl.h")] + public static unsafe int ITypeCompBindTypeStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szName, uint lHashVal, ref ITypeInfo* ppTInfo) + { + // SpanOverloader + return thisApi.ITypeCompBindTypeStub(ref This.GetPinnableReference(), szName, lHashVal, ref ppTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrProxy(this Windows thisApi, Span This, TypeAttr** ppTypeAttr) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrProxy(ref This.GetPinnableReference(), ppTypeAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6027, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrProxy(this Windows thisApi, Span This, ref TypeAttr* ppTypeAttr) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrProxy(ref This.GetPinnableReference(), ref ppTypeAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, ITypeInfo* This, TypeAttr** ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(This, ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, ITypeInfo* This, ref TypeAttr* ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(This, ref ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, Span This, TypeAttr** ppTypeAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(ref This.GetPinnableReference(), ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, Span This, TypeAttr** ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(ref This.GetPinnableReference(), ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, Span This, ref TypeAttr* ppTypeAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(ref This.GetPinnableReference(), ref ppTypeAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6032, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetTypeAttrStub(this Windows thisApi, Span This, ref TypeAttr* ppTypeAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetTypeAttrStub(ref This.GetPinnableReference(), ref ppTypeAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescProxy(this Windows thisApi, Span This, uint index, FuncDesc** ppFuncDesc) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescProxy(ref This.GetPinnableReference(), index, ppFuncDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6037, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescProxy(this Windows thisApi, Span This, uint index, ref FuncDesc* ppFuncDesc) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescProxy(ref This.GetPinnableReference(), index, ref ppFuncDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, ITypeInfo* This, uint index, FuncDesc** ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(This, index, ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, ITypeInfo* This, uint index, ref FuncDesc* ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(This, index, ref ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, Span This, uint index, FuncDesc** ppFuncDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(ref This.GetPinnableReference(), index, ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, Span This, uint index, FuncDesc** ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(ref This.GetPinnableReference(), index, ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, Span This, uint index, ref FuncDesc* ppFuncDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(ref This.GetPinnableReference(), index, ref ppFuncDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6043, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetFuncDescStub(this Windows thisApi, Span This, uint index, ref FuncDesc* ppFuncDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetFuncDescStub(ref This.GetPinnableReference(), index, ref ppFuncDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescProxy(this Windows thisApi, Span This, uint index, VarDesc** ppVarDesc) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescProxy(ref This.GetPinnableReference(), index, ppVarDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6049, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescProxy(this Windows thisApi, Span This, uint index, ref VarDesc* ppVarDesc) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescProxy(ref This.GetPinnableReference(), index, ref ppVarDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, ITypeInfo* This, uint index, VarDesc** ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(This, index, ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, ITypeInfo* This, uint index, ref VarDesc* ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(This, index, ref ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, Span This, uint index, VarDesc** ppVarDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(ref This.GetPinnableReference(), index, ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, Span This, uint index, VarDesc** ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(ref This.GetPinnableReference(), index, ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, Span This, uint index, ref VarDesc* ppVarDesc, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(ref This.GetPinnableReference(), index, ref ppVarDesc, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6055, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetVarDescStub(this Windows thisApi, Span This, uint index, ref VarDesc* ppVarDesc, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeInfoGetVarDescStub(ref This.GetPinnableReference(), index, ref ppVarDesc, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(This, memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(This, memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 6061, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesProxy(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesProxy(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, ITypeInfo* This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(This, memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, ITypeInfo* This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(This, memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, Span This, int memid, char** rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(ref This.GetPinnableReference(), memid, rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, uint* pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, pcNames); + } + + /// To be documented. + [NativeName("Src", "Line 6071, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetNamesStub(this Windows thisApi, Span This, int memid, ref char* rgBstrNames, uint cMaxNames, Span pcNames) + { + // SpanOverloader + return thisApi.ITypeInfoGetNamesStub(ref This.GetPinnableReference(), memid, ref rgBstrNames, cMaxNames, ref pcNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, ITypeInfo* This, char** rgszNames, uint cNames, Span pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(This, rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, ITypeInfo* This, ref char* rgszNames, uint cNames, Span pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(This, ref rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, Span This, char** rgszNames, uint cNames, int* pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(ref This.GetPinnableReference(), rgszNames, cNames, pMemId); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, Span This, char** rgszNames, uint cNames, Span pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(ref This.GetPinnableReference(), rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, Span This, ref char* rgszNames, uint cNames, int* pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(ref This.GetPinnableReference(), ref rgszNames, cNames, pMemId); + } + + /// To be documented. + [NativeName("Src", "Line 6078, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesProxy(this Windows thisApi, Span This, ref char* rgszNames, uint cNames, Span pMemId) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesProxy(ref This.GetPinnableReference(), ref rgszNames, cNames, ref pMemId.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6086, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoGetIDsOfNamesStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoGetIDsOfNamesStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, ITypeInfo* This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(This, ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, void* pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), pvInstance, memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, DispatchParams* pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, pDispParams, ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Variant* pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), pVarResult, ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, ExceptionInfo* pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), pExcepInfo, ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, uint* puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), puArgErr); + } + + /// To be documented. + [NativeName("Src", "Line 6089, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoInvokeProxy(this Windows thisApi, Span This, Span pvInstance, int memid, ushort wFlags, Span pDispParams, Span pVarResult, Span pExcepInfo, Span puArgErr) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ITypeInfoInvokeProxy(ref This.GetPinnableReference(), ref pvInstance.GetPinnableReference(), memid, wFlags, ref pDispParams.GetPinnableReference(), ref pVarResult.GetPinnableReference(), ref pExcepInfo.GetPinnableReference(), ref puArgErr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6100, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoInvokeStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoInvokeStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, ITypeInfo* This, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(This, memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6103, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationProxy(this Windows thisApi, Span This, int memid, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationProxy(ref This.GetPinnableReference(), memid, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, ITypeInfo* This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(This, memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6115, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDocumentationStub(this Windows thisApi, Span This, int memid, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeInfoGetDocumentationStub(ref This.GetPinnableReference(), memid, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(This, memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(This, memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(This, memid, invKind, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, ref pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, ref pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6124, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryProxy(ref This.GetPinnableReference(), memid, invKind, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, ITypeInfo* This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(This, memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, char** pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, char** pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, ushort* pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, pwOrdinal); + } + + /// To be documented. + [NativeName("Src", "Line 6135, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetDllEntryStub(this Windows thisApi, Span This, int memid, InvokeKind invKind, uint refPtrFlags, ref char* pBstrDllName, ref char* pBstrName, Span pwOrdinal) + { + // SpanOverloader + return thisApi.ITypeInfoGetDllEntryStub(ref This.GetPinnableReference(), memid, invKind, refPtrFlags, ref pBstrDllName, ref pBstrName, ref pwOrdinal.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoAddressOfMemberProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, void** ppv) + { + // SpanOverloader + return thisApi.ITypeInfoAddressOfMemberProxy(ref This.GetPinnableReference(), memid, invKind, ppv); + } + + /// To be documented. + [NativeName("Src", "Line 6144, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoAddressOfMemberProxy(this Windows thisApi, Span This, int memid, InvokeKind invKind, ref void* ppv) + { + // SpanOverloader + return thisApi.ITypeInfoAddressOfMemberProxy(ref This.GetPinnableReference(), memid, invKind, ref ppv); + } + + /// To be documented. + [NativeName("Src", "Line 6151, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoAddressOfMemberStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoAddressOfMemberStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, pUnkOuter, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, pUnkOuter, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span pUnkOuter, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, ref pUnkOuter.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span pUnkOuter, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, ref pUnkOuter.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span pUnkOuter, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, ITypeInfo* This, Span pUnkOuter, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(This, ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), pUnkOuter, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), pUnkOuter, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), pUnkOuter, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), pUnkOuter, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Span pUnkOuter, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Span pUnkOuter, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Span pUnkOuter, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6154, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceProxy(this Windows thisApi, Span This, Span pUnkOuter, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, ITypeInfo* This, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(This, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, ITypeInfo* This, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(This, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, Span This, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(ref This.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, Span This, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(ref This.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, Span This, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6161, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoCreateInstanceStub(this Windows thisApi, Span This, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.ITypeInfoCreateInstanceStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, ITypeInfo* This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(This, ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, ITypeInfo* This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(This, ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, Span This, ITypeLib** ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(ref This.GetPinnableReference(), ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, Span This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(ref This.GetPinnableReference(), ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, Span This, ref ITypeLib* ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(ref This.GetPinnableReference(), ref ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 6166, Column 41 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibProxy(this Windows thisApi, Span This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibProxy(ref This.GetPinnableReference(), ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, ITypeInfo* This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(This, ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, ITypeInfo* This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(This, ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, Span This, ITypeLib** ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(ref This.GetPinnableReference(), ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, Span This, ITypeLib** ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(ref This.GetPinnableReference(), ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, Span This, ref ITypeLib* ppTLib, uint* pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(ref This.GetPinnableReference(), ref ppTLib, pIndex); + } + + /// To be documented. + [NativeName("Src", "Line 6172, Column 43 in oaidl.h")] + public static unsafe int ITypeInfoGetContainingTypeLibStub(this Windows thisApi, Span This, ref ITypeLib* ppTLib, Span pIndex) + { + // SpanOverloader + return thisApi.ITypeInfoGetContainingTypeLibStub(ref This.GetPinnableReference(), ref ppTLib, ref pIndex.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseTypeAttrProxy(this Windows thisApi, ITypeInfo* This, Span pTypeAttr) + { + // SpanOverloader + thisApi.ITypeInfoReleaseTypeAttrProxy(This, ref pTypeAttr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseTypeAttrProxy(this Windows thisApi, Span This, TypeAttr* pTypeAttr) + { + // SpanOverloader + thisApi.ITypeInfoReleaseTypeAttrProxy(ref This.GetPinnableReference(), pTypeAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6177, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseTypeAttrProxy(this Windows thisApi, Span This, Span pTypeAttr) + { + // SpanOverloader + thisApi.ITypeInfoReleaseTypeAttrProxy(ref This.GetPinnableReference(), ref pTypeAttr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6182, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoReleaseTypeAttrStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoReleaseTypeAttrStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseFuncDescProxy(this Windows thisApi, ITypeInfo* This, Span pFuncDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseFuncDescProxy(This, ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseFuncDescProxy(this Windows thisApi, Span This, FuncDesc* pFuncDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseFuncDescProxy(ref This.GetPinnableReference(), pFuncDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6185, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseFuncDescProxy(this Windows thisApi, Span This, Span pFuncDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseFuncDescProxy(ref This.GetPinnableReference(), ref pFuncDesc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6190, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoReleaseFuncDescStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoReleaseFuncDescStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseVarDescProxy(this Windows thisApi, ITypeInfo* This, Span pVarDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseVarDescProxy(This, ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseVarDescProxy(this Windows thisApi, Span This, VarDesc* pVarDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseVarDescProxy(ref This.GetPinnableReference(), pVarDesc); + } + + /// To be documented. + [NativeName("Src", "Line 6193, Column 38 in oaidl.h")] + public static unsafe void ITypeInfoReleaseVarDescProxy(this Windows thisApi, Span This, Span pVarDesc) + { + // SpanOverloader + thisApi.ITypeInfoReleaseVarDescProxy(ref This.GetPinnableReference(), ref pVarDesc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6198, Column 51 in oaidl.h")] + public static unsafe int ITypeInfoReleaseVarDescStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeInfoReleaseVarDescStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(This, memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6201, Column 41 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Proxy(this Windows thisApi, Span This, int memid, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Proxy(ref This.GetPinnableReference(), memid, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, ITypeInfo2* This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(This, memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6212, Column 43 in oaidl.h")] + public static unsafe int ITypeInfo2GetDocumentation2Stub(this Windows thisApi, Span This, int memid, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeInfo2GetDocumentation2Stub(ref This.GetPinnableReference(), memid, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6221, Column 38 in oaidl.h")] + public static unsafe uint ITypeLibGetTypeInfoCountProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeLibGetTypeInfoCountProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetTypeInfoCountStub(this Windows thisApi, ITypeLib* This, Span pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibGetTypeInfoCountStub(This, ref pcTInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetTypeInfoCountStub(this Windows thisApi, Span This, uint* pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibGetTypeInfoCountStub(ref This.GetPinnableReference(), pcTInfo); + } + + /// To be documented. + [NativeName("Src", "Line 6225, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetTypeInfoCountStub(this Windows thisApi, Span This, Span pcTInfo) + { + // SpanOverloader + return thisApi.ITypeLibGetTypeInfoCountStub(ref This.GetPinnableReference(), ref pcTInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrProxy(this Windows thisApi, Span This, TLibAttr** ppTLibAttr) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrProxy(ref This.GetPinnableReference(), ppTLibAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6229, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrProxy(this Windows thisApi, Span This, ref TLibAttr* ppTLibAttr) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrProxy(ref This.GetPinnableReference(), ref ppTLibAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, ITypeLib* This, TLibAttr** ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(This, ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, ITypeLib* This, ref TLibAttr* ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(This, ref ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, Span This, TLibAttr** ppTLibAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(ref This.GetPinnableReference(), ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, Span This, TLibAttr** ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(ref This.GetPinnableReference(), ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, Span This, ref TLibAttr* ppTLibAttr, CleanLocalStorage* pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(ref This.GetPinnableReference(), ref ppTLibAttr, pDummy); + } + + /// To be documented. + [NativeName("Src", "Line 6234, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetLibAttrStub(this Windows thisApi, Span This, ref TLibAttr* ppTLibAttr, Span pDummy) + { + // SpanOverloader + return thisApi.ITypeLibGetLibAttrStub(ref This.GetPinnableReference(), ref ppTLibAttr, ref pDummy.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, ITypeLib* This, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(This, index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6239, Column 41 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationProxy(this Windows thisApi, Span This, int index, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationProxy(ref This.GetPinnableReference(), index, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, ITypeLib* This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(This, index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, char** pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, char** pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, uint* pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, pdwHelpContext, ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, char** pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6251, Column 43 in oaidl.h")] + public static unsafe int ITypeLibGetDocumentationStub(this Windows thisApi, Span This, int index, uint refPtrFlags, ref char* pBstrName, ref char* pBstrDocString, Span pdwHelpContext, ref char* pBstrHelpFile) + { + // SpanOverloader + return thisApi.ITypeLibGetDocumentationStub(ref This.GetPinnableReference(), index, refPtrFlags, ref pBstrName, ref pBstrDocString, ref pdwHelpContext.GetPinnableReference(), ref pBstrHelpFile); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, int* pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, pfName); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, int* pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, int* pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, pfName); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName); + } + + /// To be documented. + [NativeName("Src", "Line 6260, Column 41 in oaidl.h")] + public static unsafe int ITypeLibIsNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(This, szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, int* pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, pfName, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6268, Column 43 in oaidl.h")] + public static unsafe int ITypeLibIsNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, Span pfName, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibIsNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref pfName.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound); + } + + /// To be documented. + [NativeName("Src", "Line 6275, Column 41 in oaidl.h")] + public static unsafe int ITypeLibFindNameProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound) + { + // SpanOverloader + return thisApi.ITypeLibFindNameProxy(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, ITypeLib* This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(This, szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, char* szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, Span szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), ref szNameBuf.GetPinnableReference(), lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ITypeInfo** ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, int* rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, rgMemId, ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, ushort* pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), pcFound, ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, char** pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6285, Column 43 in oaidl.h")] + public static unsafe int ITypeLibFindNameStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string szNameBuf, uint lHashVal, ref ITypeInfo* ppTInfo, Span rgMemId, Span pcFound, ref char* pBstrLibName) + { + // SpanOverloader + return thisApi.ITypeLibFindNameStub(ref This.GetPinnableReference(), szNameBuf, lHashVal, ref ppTInfo, ref rgMemId.GetPinnableReference(), ref pcFound.GetPinnableReference(), ref pBstrLibName); + } + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + public static unsafe void ITypeLibReleaseTLibAttrProxy(this Windows thisApi, ITypeLib* This, Span pTLibAttr) + { + // SpanOverloader + thisApi.ITypeLibReleaseTLibAttrProxy(This, ref pTLibAttr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + public static unsafe void ITypeLibReleaseTLibAttrProxy(this Windows thisApi, Span This, TLibAttr* pTLibAttr) + { + // SpanOverloader + thisApi.ITypeLibReleaseTLibAttrProxy(ref This.GetPinnableReference(), pTLibAttr); + } + + /// To be documented. + [NativeName("Src", "Line 6294, Column 38 in oaidl.h")] + public static unsafe void ITypeLibReleaseTLibAttrProxy(this Windows thisApi, Span This, Span pTLibAttr) + { + // SpanOverloader + thisApi.ITypeLibReleaseTLibAttrProxy(ref This.GetPinnableReference(), ref pTLibAttr.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6299, Column 51 in oaidl.h")] + public static unsafe int ITypeLibReleaseTLibAttrStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.ITypeLibReleaseTLibAttrStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(This, pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(This, ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(This, ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, Span This, uint* pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(ref This.GetPinnableReference(), pcUniqueNames, pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, Span This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(ref This.GetPinnableReference(), pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, Span This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6302, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsProxy(this Windows thisApi, Span This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsProxy(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, ITypeLib2* This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(This, pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(This, ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, ITypeLib2* This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(This, ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, Span This, uint* pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(ref This.GetPinnableReference(), pcUniqueNames, pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, Span This, uint* pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(ref This.GetPinnableReference(), pcUniqueNames, ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, Span This, Span pcUniqueNames, uint* pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), pcchUniqueNames); + } + + /// To be documented. + [NativeName("Src", "Line 6308, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetLibStatisticsStub(this Windows thisApi, Span This, Span pcUniqueNames, Span pcchUniqueNames) + { + // SpanOverloader + return thisApi.ITypeLib2GetLibStatisticsStub(ref This.GetPinnableReference(), ref pcUniqueNames.GetPinnableReference(), ref pcchUniqueNames.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(This, index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(This, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, ITypeLib2* This, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(This, index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6313, Column 41 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Proxy(this Windows thisApi, Span This, int index, uint lcid, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Proxy(ref This.GetPinnableReference(), index, lcid, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, ITypeLib2* This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(This, index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, char** pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, uint* pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, pdwHelpStringContext, ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, char** pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6324, Column 43 in oaidl.h")] + public static unsafe int ITypeLib2GetDocumentation2Stub(this Windows thisApi, Span This, int index, uint lcid, uint refPtrFlags, ref char* pbstrHelpString, Span pdwHelpStringContext, ref char* pbstrHelpStringDll) + { + // SpanOverloader + return thisApi.ITypeLib2GetDocumentation2Stub(ref This.GetPinnableReference(), index, lcid, refPtrFlags, ref pbstrHelpString, ref pdwHelpStringContext.GetPinnableReference(), ref pbstrHelpStringDll); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, in pszPropName.GetPinnableReference(), pVar, pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog); + } + + /// To be documented. + [NativeName("Src", "Line 6333, Column 41 in oaidl.h")] + public static unsafe int IPropertyBagReadProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog) + { + // SpanOverloader + return thisApi.IPropertyBagReadProxy(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, IPropertyBag* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(This, pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), in pszPropName.GetPinnableReference(), ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Variant* pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, pVar, ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, IErrorLog* pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), pErrorLog, varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Silk.NET.Core.Native.IUnknown* pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, pUnkObj); + } + + /// To be documented. + [NativeName("Src", "Line 6340, Column 43 in oaidl.h")] + public static unsafe int IPropertyBagReadStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszPropName, Span pVar, Span pErrorLog, uint varType, Span pUnkObj) + { + // SpanOverloader + return thisApi.IPropertyBagReadStub(ref This.GetPinnableReference(), pszPropName, ref pVar.GetPinnableReference(), ref pErrorLog.GetPinnableReference(), varType, ref pUnkObj.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 969, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 976, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1108, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1115, Column 17 in propidlbase.h")] + public static unsafe void IEnumSTATPROPSETSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATPROPSETSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + public static unsafe uint LPSAFEARRAYUserSize(this Windows thisApi, Span arg0, uint arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1154, Column 39 in propidlbase.h")] + public static unsafe uint LPSAFEARRAYUserSize(this Windows thisApi, Span arg0, uint arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, uint* arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, byte* arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1155, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1156, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + public static unsafe void LPSAFEARRAYUserFree(this Windows thisApi, Span arg0, SafeArray** arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 1157, Column 39 in propidlbase.h")] + public static unsafe void LPSAFEARRAYUserFree(this Windows thisApi, Span arg0, ref SafeArray* arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + public static unsafe uint LPSAFEARRAYUserSize64(this Windows thisApi, Span arg0, uint arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1164, Column 39 in propidlbase.h")] + public static unsafe uint LPSAFEARRAYUserSize64(this Windows thisApi, Span arg0, uint arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1165, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1166, Column 29 in propidlbase.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + public static unsafe void LPSAFEARRAYUserFree64(this Windows thisApi, Span arg0, SafeArray** arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 1167, Column 39 in propidlbase.h")] + public static unsafe void LPSAFEARRAYUserFree64(this Windows thisApi, Span arg0, ref SafeArray* arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1169, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, IEnumSTATPROPSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, Span This, uint celt, STATPROPSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1178, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1184, Column 41 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, IEnumSTATPROPSETSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, Span This, uint celt, STATPROPSETSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 1193, Column 43 in propidlbase.h")] + public static unsafe int IEnumSTATPROPSETSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATPROPSETSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + public static unsafe int PropVariantCopy(this Windows thisApi, PropVariant* pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSrc) + { + // SpanOverloader + return thisApi.PropVariantCopy(pvarDest, in pvarSrc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + public static unsafe int PropVariantCopy(this Windows thisApi, Span pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvarSrc) + { + // SpanOverloader + return thisApi.PropVariantCopy(ref pvarDest.GetPinnableReference(), pvarSrc); + } + + /// To be documented. + [NativeName("Src", "Line 1215, Column 26 in propidl.h")] + public static unsafe int PropVariantCopy(this Windows thisApi, Span pvarDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSrc) + { + // SpanOverloader + return thisApi.PropVariantCopy(ref pvarDest.GetPinnableReference(), in pvarSrc.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1219, Column 11 in propidl.h")] + public static unsafe int PropVariantClear(this Windows thisApi, Span pvar) + { + // SpanOverloader + return thisApi.PropVariantClear(ref pvar.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1221, Column 11 in propidl.h")] + public static unsafe int FreePropVariantArray(this Windows thisApi, uint cVariants, Span rgvars) + { + // SpanOverloader + return thisApi.FreePropVariantArray(cVariants, ref rgvars.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, pprop, pcb, pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, Span pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, pprop, ref pcb.GetPinnableReference(), pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, SerializedPropertyValue* pprop, Span pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, pprop, ref pcb.GetPinnableReference(), pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, Span pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, ref pprop.GetPinnableReference(), pcb, pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, Span pprop, uint* pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, ref pprop.GetPinnableReference(), pcb, pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, Span pprop, Span pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, ref pprop.GetPinnableReference(), ref pcb.GetPinnableReference(), pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] PropVariant* pvar, ushort CodePage, Span pprop, Span pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(pvar, CodePage, ref pprop.GetPinnableReference(), ref pcb.GetPinnableReference(), pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, pprop, pcb, pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, SerializedPropertyValue* pprop, uint* pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, pprop, pcb, pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, SerializedPropertyValue* pprop, Span pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, pprop, ref pcb.GetPinnableReference(), pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, SerializedPropertyValue* pprop, Span pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, pprop, ref pcb.GetPinnableReference(), pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, Span pprop, uint* pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, ref pprop.GetPinnableReference(), pcb, pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, Span pprop, uint* pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, ref pprop.GetPinnableReference(), pcb, pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, Span pprop, Span pcb, uint pid, byte fReserved, uint* pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, ref pprop.GetPinnableReference(), ref pcb.GetPinnableReference(), pid, fReserved, pcIndirect); + } + + /// To be documented. + [NativeName("Src", "Line 1265, Column 1 in propidl.h")] + public static unsafe SerializedPropertyValue* StgConvertVariantToProperty(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvar, ushort CodePage, Span pprop, Span pcb, uint pid, byte fReserved, Span pcIndirect) + { + // SpanOverloader + return thisApi.StgConvertVariantToProperty(in pvar.GetPinnableReference(), CodePage, ref pprop.GetPinnableReference(), ref pcb.GetPinnableReference(), pid, fReserved, ref pcIndirect.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + public static unsafe byte StgConvertPropertyToVariant(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SerializedPropertyValue* pprop, ushort CodePage, Span pvar, PMemoryAllocator* pma) + { + // SpanOverloader + return thisApi.StgConvertPropertyToVariant(pprop, CodePage, ref pvar.GetPinnableReference(), pma); + } + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + public static unsafe byte StgConvertPropertyToVariant(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pprop, ushort CodePage, PropVariant* pvar, PMemoryAllocator* pma) + { + // SpanOverloader + return thisApi.StgConvertPropertyToVariant(in pprop.GetPinnableReference(), CodePage, pvar, pma); + } + + /// To be documented. + [NativeName("Src", "Line 1280, Column 1 in propidl.h")] + public static unsafe byte StgConvertPropertyToVariant(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pprop, ushort CodePage, Span pvar, PMemoryAllocator* pma) + { + // SpanOverloader + return thisApi.StgConvertPropertyToVariant(in pprop.GetPinnableReference(), CodePage, ref pvar.GetPinnableReference(), pma); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(This, cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(This, cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(This, cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, rgcd, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 588, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 595, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(This, cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(This, cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ref ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 859, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsRemoteNextProxy(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsRemoteNextProxy(ref This.GetPinnableReference(), cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 866, Column 17 in ocidl.h")] + public static unsafe void IEnumConnectionPointsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumConnectionPointsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Guid* riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Guid* riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(This, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1145, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2RemoteCreateInstanceLicProxy(this Windows thisApi, Span This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2RemoteCreateInstanceLicProxy(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1152, Column 17 in ocidl.h")] + public static unsafe void IClassFactory2RemoteCreateInstanceLicStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IClassFactory2RemoteCreateInstanceLicStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteLoadProxy(this Windows thisApi, IPersistMemory* This, Span pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteLoadProxy(This, ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteLoadProxy(this Windows thisApi, Span This, byte* pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteLoadProxy(ref This.GetPinnableReference(), pMem, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteLoadProxy(this Windows thisApi, Span This, Span pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteLoadProxy(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2631, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteLoadProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteLoadProxy(ref This.GetPinnableReference(), pMem, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2637, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteLoadStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteLoadStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteSaveProxy(this Windows thisApi, IPersistMemory* This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteSaveProxy(This, ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteSaveProxy(this Windows thisApi, Span This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteSaveProxy(ref This.GetPinnableReference(), pMem, fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteSaveProxy(this Windows thisApi, Span This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteSaveProxy(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2644, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryRemoteSaveProxy(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryRemoteSaveProxy(ref This.GetPinnableReference(), pMem, fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2651, Column 17 in ocidl.h")] + public static unsafe void IPersistMemoryRemoteSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IPersistMemoryRemoteSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(This, cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(This, cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(ref This.GetPinnableReference(), cElt, rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(ref This.GetPinnableReference(), cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(ref This.GetPinnableReference(), cElt, ref rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 5735, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsRemoteNextProxy(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsRemoteNextProxy(ref This.GetPinnableReference(), cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 5742, Column 17 in ocidl.h")] + public static unsafe void IEnumOleUndoUnitsRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumOleUndoUnitsRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6819, Column 43 in ocidl.h")] + public static unsafe int IAdviseSinkExRemoteOnViewStatusChangeProxy(this Windows thisApi, Span This, uint dwViewStatus) + { + // SpanOverloader + return thisApi.IAdviseSinkExRemoteOnViewStatusChangeProxy(ref This.GetPinnableReference(), dwViewStatus); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6824, Column 17 in ocidl.h")] + public static unsafe void IAdviseSinkExRemoteOnViewStatusChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkExRemoteOnViewStatusChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(This, pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(This, ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(This, ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Span This, void* pQaContainer, QAControl* pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(ref This.GetPinnableReference(), pQaContainer, pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Span This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(ref This.GetPinnableReference(), pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Span This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 6998, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateRemoteQuickActivateProxy(this Windows thisApi, Span This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateRemoteQuickActivateProxy(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 7004, Column 17 in ocidl.h")] + public static unsafe void IQuickActivateRemoteQuickActivateStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IQuickActivateRemoteQuickActivateStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + public static unsafe uint HACCELUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7040, Column 39 in ocidl.h")] + public static unsafe uint HACCELUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7041, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7042, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + public static unsafe void HACCELUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HACCELUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7043, Column 39 in ocidl.h")] + public static unsafe void HACCELUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HACCELUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + public static unsafe uint HFONTUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7050, Column 39 in ocidl.h")] + public static unsafe uint HFONTUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7051, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7052, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + public static unsafe void HFONTUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HFONTUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7053, Column 39 in ocidl.h")] + public static unsafe void HFONTUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HFONTUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + public static unsafe uint HPALETTEUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7055, Column 39 in ocidl.h")] + public static unsafe uint HPALETTEUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7056, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7057, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + public static unsafe void HPALETTEUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7058, Column 39 in ocidl.h")] + public static unsafe void HPALETTEUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + public static unsafe uint HRGNUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7060, Column 39 in ocidl.h")] + public static unsafe uint HRGNUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7061, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7062, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + public static unsafe void HRGNUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HRGNUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7063, Column 39 in ocidl.h")] + public static unsafe void HRGNUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HRGNUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize(this Windows thisApi, Span arg0, uint arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7065, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7066, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7067, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.HWNDUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree(this Windows thisApi, Span arg0, nint* arg1) + { + // SpanOverloader + thisApi.HWNDUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7068, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.HWNDUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + public static unsafe uint HACCELUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7085, Column 39 in ocidl.h")] + public static unsafe uint HACCELUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7086, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7087, Column 29 in ocidl.h")] + public static unsafe byte* HACCELUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HACCELUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + public static unsafe void HACCELUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HACCELUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7088, Column 39 in ocidl.h")] + public static unsafe void HACCELUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HACCELUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + public static unsafe uint HFONTUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7095, Column 39 in ocidl.h")] + public static unsafe uint HFONTUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7096, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7097, Column 29 in ocidl.h")] + public static unsafe byte* HFONTUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HFONTUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + public static unsafe void HFONTUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HFONTUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7098, Column 39 in ocidl.h")] + public static unsafe void HFONTUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HFONTUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + public static unsafe uint HPALETTEUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7100, Column 39 in ocidl.h")] + public static unsafe uint HPALETTEUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7101, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7102, Column 29 in ocidl.h")] + public static unsafe byte* HPALETTEUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + public static unsafe void HPALETTEUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7103, Column 39 in ocidl.h")] + public static unsafe void HPALETTEUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + public static unsafe uint HRGNUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7105, Column 39 in ocidl.h")] + public static unsafe uint HRGNUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7106, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7107, Column 29 in ocidl.h")] + public static unsafe byte* HRGNUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HRGNUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + public static unsafe void HRGNUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HRGNUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7108, Column 39 in ocidl.h")] + public static unsafe void HRGNUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HRGNUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize64(this Windows thisApi, Span arg0, uint arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7110, Column 39 in ocidl.h")] + public static unsafe uint HWNDUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7111, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 7112, Column 29 in ocidl.h")] + public static unsafe byte* HWNDUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HWNDUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.HWNDUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree64(this Windows thisApi, Span arg0, nint* arg1) + { + // SpanOverloader + thisApi.HWNDUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 7113, Column 39 in ocidl.h")] + public static unsafe void HWNDUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.HWNDUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(This, cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(This, cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(This, cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(ref This.GetPinnableReference(), cConnections, rgcd, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(ref This.GetPinnableReference(), cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, Span This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7120, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionsNextProxy(this Windows thisApi, Span This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextProxy(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, IEnumConnections* This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(This, cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(This, cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, IEnumConnections* This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(This, cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(ref This.GetPinnableReference(), cConnections, rgcd, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, Span This, uint cConnections, ConnectData* rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(ref This.GetPinnableReference(), cConnections, rgcd, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, Span This, uint cConnections, Span rgcd, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7127, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionsNextStub(this Windows thisApi, Span This, uint cConnections, Span rgcd, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionsNextStub(ref This.GetPinnableReference(), cConnections, ref rgcd.GetPinnableReference(), ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(This, cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(This, cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(ref This.GetPinnableReference(), cConnections, ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(ref This.GetPinnableReference(), cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(ref This.GetPinnableReference(), cConnections, ref ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7133, Column 41 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextProxy(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextProxy(ref This.GetPinnableReference(), cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(This, cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, IEnumConnectionPoints* This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(This, cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(ref This.GetPinnableReference(), cConnections, ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, Span This, uint cConnections, IConnectionPoint** ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(ref This.GetPinnableReference(), cConnections, ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, uint* pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(ref This.GetPinnableReference(), cConnections, ref ppCP, pcFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7140, Column 43 in ocidl.h")] + public static unsafe int IEnumConnectionPointsNextStub(this Windows thisApi, Span This, uint cConnections, ref IConnectionPoint* ppCP, Span pcFetched) + { + // SpanOverloader + return thisApi.IEnumConnectionPointsNextStub(ref This.GetPinnableReference(), cConnections, ref ppCP, ref pcFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(This, ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Silk.NET.Core.Native.IUnknown* pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), pUnkOuter, ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Silk.NET.Core.Native.IUnknown* pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), pUnkReserved, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, char* bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, Span bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, void** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7146, Column 41 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicProxy(this Windows thisApi, Span This, Span pUnkOuter, Span pUnkReserved, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicProxy(ref This.GetPinnableReference(), ref pUnkOuter.GetPinnableReference(), ref pUnkReserved.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Guid* riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Guid* riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(This, ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Guid* riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), riid, bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, char* bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, char* bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, Span bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, Span bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), ref bstrKey.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7160, Column 43 in ocidl.h")] + public static unsafe int IClassFactory2CreateInstanceLicStub(this Windows thisApi, Span This, Span riid, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.BStr)] string bstrKey, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IClassFactory2CreateInstanceLicStub(ref This.GetPinnableReference(), ref riid.GetPinnableReference(), bstrKey, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + public static unsafe int IPersistMemoryLoadProxy(this Windows thisApi, IPersistMemory* This, Span pMem, uint cbSize) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IPersistMemoryLoadProxy(This, ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + public static unsafe int IPersistMemoryLoadProxy(this Windows thisApi, Span This, void* pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryLoadProxy(ref This.GetPinnableReference(), pMem, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7166, Column 41 in ocidl.h")] + public static unsafe int IPersistMemoryLoadProxy(this Windows thisApi, Span This, Span pMem, uint cbSize) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IPersistMemoryLoadProxy(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryLoadStub(this Windows thisApi, IPersistMemory* This, Span pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryLoadStub(This, ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryLoadStub(this Windows thisApi, Span This, byte* pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryLoadStub(ref This.GetPinnableReference(), pMem, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryLoadStub(this Windows thisApi, Span This, Span pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryLoadStub(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7172, Column 43 in ocidl.h")] + public static unsafe int IPersistMemoryLoadStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemoryLoadStub(ref This.GetPinnableReference(), pMem, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + public static unsafe int IPersistMemorySaveProxy(this Windows thisApi, IPersistMemory* This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IPersistMemorySaveProxy(This, ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + public static unsafe int IPersistMemorySaveProxy(this Windows thisApi, Span This, void* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemorySaveProxy(ref This.GetPinnableReference(), pMem, fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7177, Column 41 in ocidl.h")] + public static unsafe int IPersistMemorySaveProxy(this Windows thisApi, Span This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IPersistMemorySaveProxy(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public static unsafe int IPersistMemorySaveStub(this Windows thisApi, IPersistMemory* This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemorySaveStub(This, ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public static unsafe int IPersistMemorySaveStub(this Windows thisApi, Span This, byte* pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemorySaveStub(ref This.GetPinnableReference(), pMem, fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public static unsafe int IPersistMemorySaveStub(this Windows thisApi, Span This, Span pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemorySaveStub(ref This.GetPinnableReference(), ref pMem.GetPinnableReference(), fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7184, Column 43 in ocidl.h")] + public static unsafe int IPersistMemorySaveStub(this Windows thisApi, Span This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pMem, Silk.NET.Core.Bool32 fClearDirty, uint cbSize) + { + // SpanOverloader + return thisApi.IPersistMemorySaveStub(ref This.GetPinnableReference(), pMem, fClearDirty, cbSize); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(This, cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(This, cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(ref This.GetPinnableReference(), cElt, rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(ref This.GetPinnableReference(), cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(ref This.GetPinnableReference(), cElt, ref rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7190, Column 41 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextProxy(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextProxy(ref This.GetPinnableReference(), cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(This, cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, IEnumOleUndoUnits* This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(This, cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(ref This.GetPinnableReference(), cElt, rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, Span This, uint cElt, IOleUndoUnit** rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(ref This.GetPinnableReference(), cElt, rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, uint* pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(ref This.GetPinnableReference(), cElt, ref rgElt, pcEltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 7197, Column 43 in ocidl.h")] + public static unsafe int IEnumOleUndoUnitsNextStub(this Windows thisApi, Span This, uint cElt, ref IOleUndoUnit* rgElt, Span pcEltFetched) + { + // SpanOverloader + return thisApi.IEnumOleUndoUnitsNextStub(ref This.GetPinnableReference(), cElt, ref rgElt, ref pcEltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7203, Column 38 in ocidl.h")] + public static unsafe void IAdviseSinkExOnViewStatusChangeProxy(this Windows thisApi, Span This, uint dwViewStatus) + { + // SpanOverloader + thisApi.IAdviseSinkExOnViewStatusChangeProxy(ref This.GetPinnableReference(), dwViewStatus); + } + + /// To be documented. + [NativeName("Src", "Line 7208, Column 43 in ocidl.h")] + public static unsafe int IAdviseSinkExOnViewStatusChangeStub(this Windows thisApi, Span This, uint dwViewStatus) + { + // SpanOverloader + return thisApi.IAdviseSinkExOnViewStatusChangeStub(ref This.GetPinnableReference(), dwViewStatus); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(This, pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(This, ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(This, ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Span This, void* pQaContainer, QAControl* pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(ref This.GetPinnableReference(), pQaContainer, pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Span This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(ref This.GetPinnableReference(), pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Span This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7212, Column 41 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateProxy(this Windows thisApi, Span This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateProxy(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(This, pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(This, ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Silk.NET.Core.Native.IUnknown* This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(This, ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Span This, void* pQaContainer, QAControl* pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(ref This.GetPinnableReference(), pQaContainer, pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Span This, void* pQaContainer, Span pQaControl) + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(ref This.GetPinnableReference(), pQaContainer, ref pQaControl.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Span This, Span pQaContainer, QAControl* pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), pQaControl); + } + + /// To be documented. + [NativeName("Src", "Line 7218, Column 43 in ocidl.h")] + public static unsafe int IQuickActivateQuickActivateStub(this Windows thisApi, Span This, Span pQaContainer, Span pQaControl) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IQuickActivateQuickActivateStub(ref This.GetPinnableReference(), ref pQaContainer.GetPinnableReference(), ref pQaControl.GetPinnableReference()); + } + /// To be documented. [NativeName("Src", "Line 541, Column 1 in evntprov.h")] public static unsafe uint EventRegister(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, Span RegHandle) diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs index d27d6f85d6..718fbb796f 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs @@ -258,48 +258,48 @@ public readonly int SetPreview(ref IWICBitmapSource pIPreview) } /// To be documented. - public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); return ret; } /// To be documented. - public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptionsPtr = &ppIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); } return ret; } /// To be documented. - public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) { - fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptionsPtr = &ppIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); } } return ret; @@ -393,29 +393,21 @@ public readonly int SetPreview(ComPtr pIPreview) where TI0 : unmanaged } /// To be documented. - public readonly int CreateNewFrame(ref ComPtr ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader - return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ppIEncoderOptions); } /// To be documented. - public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref ppIEncoderOptions); } - /// To be documented. - public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - // ComPtrOverloader - return @this->CreateNewFrame(ref ppIFrameEncode, (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); - } - /// To be documented. public readonly int GetMetadataQueryWriter(ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs index 6ea24562d5..347bec9b05 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs @@ -111,22 +111,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Initialize(Silk.NET.Core.Native.IUnknown* pIEncoderOptions) + public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IPropertyBag2* pIEncoderOptions) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); return ret; } /// To be documented. - public readonly int Initialize(ref Silk.NET.Core.Native.IUnknown pIEncoderOptions) + public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IPropertyBag2 pIEncoderOptions) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Silk.NET.Core.Native.IUnknown* pIEncoderOptionsPtr = &pIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2* pIEncoderOptionsPtr = &pIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); } return ret; } @@ -352,14 +352,6 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); } - /// To be documented. - public readonly int Initialize(ComPtr pIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - // ComPtrOverloader - return @this->Initialize((Silk.NET.Core.Native.IUnknown*) pIEncoderOptions.Handle); - } - /// To be documented. public readonly int SetColorContexts(uint cCount, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs index 2ea66b0087..026faf6783 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs @@ -2455,48 +2455,48 @@ public readonly unsafe int CreateQueryWriterFromBlockWriter(ref IWICMetadataBloc } /// To be documented. - public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) + public readonly unsafe int CreateEncoderPropertyBag(Silk.NET.Core.Win32Extras.PropBag2* ppropOptions, uint cCount, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBag) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); return ret; } /// To be documented. - public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) + public readonly unsafe int CreateEncoderPropertyBag(Silk.NET.Core.Win32Extras.PropBag2* ppropOptions, uint cCount, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIPropertyBag) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBagPtr = &ppIPropertyBag) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + public readonly unsafe int CreateEncoderPropertyBag(ref Silk.NET.Core.Win32Extras.PropBag2 ppropOptions, uint cCount, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBag) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* ppropOptionsPtr = &ppropOptions) + fixed (Silk.NET.Core.Win32Extras.PropBag2* ppropOptionsPtr = &ppropOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); } return ret; } /// To be documented. - public readonly unsafe int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + public readonly unsafe int CreateEncoderPropertyBag(ref Silk.NET.Core.Win32Extras.PropBag2 ppropOptions, uint cCount, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIPropertyBag) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* ppropOptionsPtr = &ppropOptions) + fixed (Silk.NET.Core.Win32Extras.PropBag2* ppropOptionsPtr = &ppropOptions) { - fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBagPtr = &ppIPropertyBag) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); } } return ret; @@ -3386,22 +3386,6 @@ public readonly int CreateQueryWriterFromBlockWriter(ref IWICMetadataBlockW return @this->CreateQueryWriterFromBlockWriter(ref pIBlockWriter, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); } - /// To be documented. - public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - // ComPtrOverloader - return @this->CreateEncoderPropertyBag(ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); - } - - /// To be documented. - public readonly int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - // ComPtrOverloader - return @this->CreateEncoderPropertyBag(ref ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); - } - /// To be documented. public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs index 4235761176..6b97a28dd7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs @@ -448,22 +448,22 @@ public readonly int LoadParameterSet(RawParameterSet ParameterSet) } /// To be documented. - public readonly unsafe int GetCurrentParameterSet(Silk.NET.Core.Native.IUnknown** ppCurrentParameterSet) + public readonly unsafe int GetCurrentParameterSet(Silk.NET.Core.Win32Extras.IPropertyBag2** ppCurrentParameterSet) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); return ret; } /// To be documented. - public readonly unsafe int GetCurrentParameterSet(ref Silk.NET.Core.Native.IUnknown* ppCurrentParameterSet) + public readonly unsafe int GetCurrentParameterSet(ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppCurrentParameterSet) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppCurrentParameterSetPtr = &ppCurrentParameterSet) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppCurrentParameterSetPtr = &ppCurrentParameterSet) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); } return ret; } @@ -1183,14 +1183,6 @@ public readonly int GetThumbnail(ref ComPtr ppIThumbnail) where TI0 : return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); } - /// To be documented. - public readonly int GetCurrentParameterSet(ref ComPtr ppCurrentParameterSet) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - // ComPtrOverloader - return @this->GetCurrentParameterSet((Silk.NET.Core.Native.IUnknown**) ppCurrentParameterSet.GetAddressOf()); - } - /// To be documented. public readonly int SetDestinationColorContext(ComPtr pColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs index 3cf2b33545..2a7db0c0aa 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs @@ -111,107 +111,107 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, uint* pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); } } } @@ -219,59 +219,59 @@ public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rge } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); } } } @@ -279,32 +279,32 @@ public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rge } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); } } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); } } } @@ -312,17 +312,17 @@ public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rg } /// To be documented. - public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly unsafe int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); } } } @@ -330,19 +330,19 @@ public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T } /// To be documented. - public readonly int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int Next(uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); } } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs index abe9400c30..3b23225ec2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs @@ -205,73 +205,73 @@ public readonly int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core. } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs index ac26529edf..41dc21c290 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs @@ -208,73 +208,73 @@ public readonly int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core. } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; @@ -302,73 +302,73 @@ public readonly unsafe int GetEnumerator(ref Silk.NET.Core.Win32Extras.IEnumStri } /// To be documented. - public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); return ret; } /// To be documented. - public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs index 5cf0a09212..41e1d9c46c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs @@ -174,107 +174,107 @@ public readonly int GetCount(ref uint pcCount) } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -282,107 +282,107 @@ public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs index 8544065498..c1560a83d7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs @@ -177,107 +177,107 @@ public readonly int GetCount(ref uint pcCount) } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int GetValueByIndex(uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -285,107 +285,107 @@ public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -414,107 +414,107 @@ public readonly unsafe int GetEnumerator(ref IWICEnumMetadataItem* ppIEnumMetada } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -522,107 +522,107 @@ public readonly int SetValue([Flow(Silk.NET.Core.Native.FlowDirectio } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public readonly int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public readonly int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -630,48 +630,48 @@ public readonly int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core } /// To be documented. - public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); return ret; } /// To be documented. - public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId) where T0 : unmanaged + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); } return ret; } /// To be documented. - public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); } return ret; } /// To be documented. - public readonly int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId) where T0 : unmanaged where T1 : unmanaged + public readonly int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId) { var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); } } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs index 840e15d526..d59a8d3c3a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs @@ -232,48 +232,48 @@ public static int SetPreview(this ComPtr thisVtbl, ref IWICBi } /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); return ret; } /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptionsPtr = &ppIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); } return ret; } /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); } return ret; } /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) { - fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptionsPtr = &ppIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); } } return ret; @@ -423,29 +423,21 @@ public static int SetPreview(this ComPtr thisVtbl, SpanTo be documented. - public static int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader - return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ppIEncoderOptions); } /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref ppIEncoderOptions); } - /// To be documented. - public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = thisVtbl.Handle; - // ComPtrOverloader - return @this->CreateNewFrame(ref ppIFrameEncode, (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); - } - /// To be documented. public static int GetMetadataQueryWriter(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs index 0f3a1407a5..17c3af2bbd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pIEncoderOptions) + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IPropertyBag2* pIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pIEncoderOptions) + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IPropertyBag2 pIEncoderOptions) { var @this = thisVtbl.Handle; int ret = default; - fixed (Silk.NET.Core.Native.IUnknown* pIEncoderOptionsPtr = &pIEncoderOptions) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2* pIEncoderOptionsPtr = &pIEncoderOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); } return ret; } @@ -343,15 +343,7 @@ public static unsafe int QueryInterface(this ComPtr thisV } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = thisVtbl.Handle; - // ComPtrOverloader - return @this->Initialize((Silk.NET.Core.Native.IUnknown*) pIEncoderOptions.Handle); - } - - /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pIEncoderOptions) + public static int Initialize(this ComPtr thisVtbl, Span pIEncoderOptions) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs index fdf733992d..d0588cceba 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs @@ -2426,48 +2426,48 @@ public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtrTo be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.PropBag2* ppropOptions, uint cCount, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBag) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); return ret; } /// To be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.PropBag2* ppropOptions, uint cCount, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIPropertyBag) { var @this = thisVtbl.Handle; int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBagPtr = &ppIPropertyBag) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); } return ret; } /// To be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.PropBag2 ppropOptions, uint cCount, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBag) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* ppropOptionsPtr = &ppropOptions) + fixed (Silk.NET.Core.Win32Extras.PropBag2* ppropOptionsPtr = &ppropOptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); } return ret; } /// To be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.PropBag2 ppropOptions, uint cCount, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIPropertyBag) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* ppropOptionsPtr = &ppropOptions) + fixed (Silk.NET.Core.Win32Extras.PropBag2* ppropOptionsPtr = &ppropOptions) { - fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBagPtr = &ppIPropertyBag) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); } } return ret; @@ -4270,15 +4270,7 @@ public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtrTo be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = thisVtbl.Handle; - // ComPtrOverloader - return @this->CreateEncoderPropertyBag(ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); - } - - /// To be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, Silk.NET.Core.Win32Extras.IPropertyBag2** ppIPropertyBag) { var @this = thisVtbl.Handle; // SpanOverloader @@ -4286,15 +4278,7 @@ public static unsafe int CreateEncoderPropertyBag(this ComPtrTo be documented. - public static int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = thisVtbl.Handle; - // ComPtrOverloader - return @this->CreateEncoderPropertyBag(ref ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); - } - - /// To be documented. - public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppIPropertyBag) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs index 7a4207c84e..27a9917453 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs @@ -416,22 +416,22 @@ public static int LoadParameterSet(this ComPtr thisVtbl, RawPara } /// To be documented. - public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown** ppCurrentParameterSet) + public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IPropertyBag2** ppCurrentParameterSet) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); return ret; } /// To be documented. - public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown* ppCurrentParameterSet) + public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IPropertyBag2* ppCurrentParameterSet) { var @this = thisVtbl.Handle; int ret = default; - fixed (Silk.NET.Core.Native.IUnknown** ppCurrentParameterSetPtr = &ppCurrentParameterSet) + fixed (Silk.NET.Core.Win32Extras.IPropertyBag2** ppCurrentParameterSetPtr = &ppCurrentParameterSet) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); } return ret; } @@ -1287,14 +1287,6 @@ public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, return @this->QueryRawCapabilitiesInfo(ref pInfo.GetPinnableReference()); } - /// To be documented. - public static int GetCurrentParameterSet(this ComPtr thisVtbl, ref ComPtr ppCurrentParameterSet) where TI0 : unmanaged, IComVtbl, IComVtbl - { - var @this = thisVtbl.Handle; - // ComPtrOverloader - return @this->GetCurrentParameterSet((Silk.NET.Core.Native.IUnknown**) ppCurrentParameterSet.GetAddressOf()); - } - /// To be documented. public static int GetExposureCompensation(this ComPtr thisVtbl, Span pEV) { diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs index 9ac64edc94..ff559bc7ff 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs @@ -85,107 +85,107 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); } } } @@ -193,59 +193,59 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); } } } @@ -253,32 +253,32 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); } } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); } } } @@ -286,17 +286,17 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); } } } @@ -304,19 +304,19 @@ public static unsafe int Next(this ComPtr this } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int Next(this ComPtr thisVtbl, uint celt, ref Silk.NET.Core.Win32Extras.PropVariant rgeltSchema, ref Silk.NET.Core.Win32Extras.PropVariant rgeltId, ref Silk.NET.Core.Win32Extras.PropVariant rgeltValue, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* rgeltSchemaPtr = &rgeltSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltSchemaPtr = &rgeltSchema) { - fixed (void* rgeltIdPtr = &rgeltId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltIdPtr = &rgeltId) { - fixed (void* rgeltValuePtr = &rgeltValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* rgeltValuePtr = &rgeltValue) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); } } } @@ -389,7 +389,7 @@ public static unsafe int QueryInterface(this ComPtr thisVt } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, Span pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -397,7 +397,7 @@ public static unsafe int Next(this ComPtr thisVtbl, uint c } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Span rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -405,7 +405,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Span rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -413,7 +413,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Span rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -421,7 +421,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Span rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -429,7 +429,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -437,7 +437,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Silk.NET.Core.Win32Extras.PropVariant* rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -445,7 +445,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -453,7 +453,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -461,7 +461,7 @@ public static unsafe int Next(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Span rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -469,7 +469,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Silk.NET.Core.Win32Extras.PropVariant* rgeltId, Span rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -477,7 +477,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -485,7 +485,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Silk.NET.Core.Win32Extras.PropVariant* rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -493,7 +493,7 @@ public static unsafe int Next(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -501,7 +501,7 @@ public static unsafe int Next(this ComPtr this } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs index 6e51a10eca..1988c4f064 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs @@ -179,73 +179,73 @@ public static int GetLocation(this ComPtr thisVtbl, uin } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref T0 pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; @@ -338,7 +338,7 @@ public static int GetLocation(this ComPtr thisVtbl, uin } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) where T0 : unmanaged + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -346,7 +346,7 @@ public static unsafe int GetMetadataByName(this ComPtrTo be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -354,7 +354,7 @@ public static unsafe int GetMetadataByName(this ComPtr } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -362,7 +362,7 @@ public static int GetMetadataByName(this ComPtr thi } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs index b64a8aa3a6..1cce84a3d7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs @@ -179,73 +179,73 @@ public static int GetLocation(this ComPtr thisVtbl, uin } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref T0 pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; @@ -273,73 +273,73 @@ public static unsafe int GetEnumerator(this ComPtr this } /// To be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); return ret; } /// To be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); } return ret; } /// To be documented. - public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzNamePtr = &wzName) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); SilkMarshal.Free((nint)wzNamePtr); return ret; } /// To be documented. - public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); } SilkMarshal.Free((nint)wzNamePtr); return ret; @@ -443,7 +443,7 @@ public static int GetLocation(this ComPtr thisVtbl, uin } /// To be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) where T0 : unmanaged + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -451,7 +451,7 @@ public static unsafe int GetMetadataByName(this ComPtrTo be documented. - public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, void* pvarValue) + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -459,7 +459,7 @@ public static unsafe int GetMetadataByName(this ComPtr } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -467,7 +467,7 @@ public static int GetMetadataByName(this ComPtr thi } /// To be documented. - public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) where T0 : unmanaged + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -475,7 +475,7 @@ public static int GetMetadataByName(this ComPtr thi } /// To be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -483,7 +483,7 @@ public static unsafe int SetMetadataByName(this ComPtrTo be documented. - public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -491,7 +491,7 @@ public static unsafe int SetMetadataByName(this ComPtr } /// To be documented. - public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -499,7 +499,7 @@ public static int SetMetadataByName(this ComPtr thi } /// To be documented. - public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs index cfcf72fa83..5a2b6006e8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs @@ -148,107 +148,107 @@ public static int GetCount(this ComPtr thisVtbl, ref uint pc } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -256,107 +256,107 @@ public static int GetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -434,7 +434,7 @@ public static int GetCount(this ComPtr thisVtbl, Span } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -442,7 +442,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Span pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -450,7 +450,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Span pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -458,7 +458,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -466,7 +466,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -474,7 +474,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -482,7 +482,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -490,7 +490,7 @@ public static int GetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -498,7 +498,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -506,7 +506,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -514,7 +514,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -522,7 +522,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -530,7 +530,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -538,7 +538,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs index b9cfe681bf..2870689249 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs @@ -148,107 +148,107 @@ public static int GetCount(this ComPtr thisVtbl, ref uint pc } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref Silk.NET.Core.Win32Extras.PropVariant pvarSchema, ref Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -256,107 +256,107 @@ public static int GetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, ref Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -385,107 +385,107 @@ public static unsafe int GetEnumerator(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -493,107 +493,107 @@ public static int SetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); } return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); } return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); } return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); } } return ret; } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); } } return ret; } /// To be documented. - public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarValue) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - fixed (void* pvarValuePtr = &pvarValue) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarValuePtr = &pvarValue) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); } } } @@ -601,48 +601,48 @@ public static int SetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); return ret; } /// To be documented. - public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarId) where T0 : unmanaged + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); } return ret; } /// To be documented. - public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); } return ret; } /// To be documented. - public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in T1 pvarId) where T0 : unmanaged where T1 : unmanaged + public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] [RequiresLocation] in Silk.NET.Core.Win32Extras.PropVariant pvarId) { var @this = thisVtbl.Handle; int ret = default; - fixed (void* pvarSchemaPtr = &pvarSchema) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarSchemaPtr = &pvarSchema) { - fixed (void* pvarIdPtr = &pvarId) + fixed (Silk.NET.Core.Win32Extras.PropVariant* pvarIdPtr = &pvarId) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); } } return ret; @@ -707,7 +707,7 @@ public static int GetCount(this ComPtr thisVtbl, Span } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -715,7 +715,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Span pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -723,7 +723,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, Span pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -731,7 +731,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -739,7 +739,7 @@ public static unsafe int GetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -747,7 +747,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -755,7 +755,7 @@ public static unsafe int GetValueByIndex(this ComPtr } /// To be documented. - public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -763,7 +763,7 @@ public static int GetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -771,7 +771,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -779,7 +779,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -787,7 +787,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -795,7 +795,7 @@ public static unsafe int GetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -803,7 +803,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -811,7 +811,7 @@ public static unsafe int GetValue(this ComPtr thisVt } /// To be documented. - public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -827,7 +827,7 @@ public static int GetEnumerator(this ComPtr thisVtbl, r } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -835,7 +835,7 @@ public static unsafe int SetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -843,7 +843,7 @@ public static unsafe int SetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -851,7 +851,7 @@ public static unsafe int SetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -859,7 +859,7 @@ public static unsafe int SetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -867,7 +867,7 @@ public static unsafe int SetValue(this ComPtr thisVt } /// To be documented. - public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -875,7 +875,7 @@ public static unsafe int SetValue(this ComPtr thisVt } /// To be documented. - public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -883,7 +883,7 @@ public static int SetValue(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -891,7 +891,7 @@ public static unsafe int SetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -899,7 +899,7 @@ public static unsafe int SetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -907,7 +907,7 @@ public static unsafe int SetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -915,7 +915,7 @@ public static unsafe int SetValueByIndex(this ComPtr thi } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -923,7 +923,7 @@ public static unsafe int SetValueByIndex(this ComPtr } /// To be documented. - public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -931,7 +931,7 @@ public static unsafe int SetValueByIndex(this ComPtr } /// To be documented. - public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -939,7 +939,7 @@ public static int SetValueByIndex(this ComPtr th } /// To be documented. - public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) where T0 : unmanaged + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) { var @this = thisVtbl.Handle; // SpanOverloader @@ -947,7 +947,7 @@ public static unsafe int RemoveValue(this ComPtr thisVtb } /// To be documented. - public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Core.Win32Extras.PropVariant* pvarId) { var @this = thisVtbl.Handle; // SpanOverloader @@ -955,7 +955,7 @@ public static unsafe int RemoveValue(this ComPtr thisVtb } /// To be documented. - public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) where T0 : unmanaged where T1 : unmanaged + public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) { var @this = thisVtbl.Handle; // SpanOverloader